sqlschema

type BaseColumn ¶

type BaseColumn struct {
	Name            string
	SQLType         string
	VarcharLen      int
	DefaultValue    string
	IsNullable      bool
	IsAutoIncrement bool
	IsIdentity      bool
}

BaseColumn is a base column definition that stores various attributes of a column.

Dialects and only dialects can use it to implement the Column interface. Other packages must use the Column interface.

func (c *BaseColumn) AppendQuery(gen schema.QueryGen, b []byte) (_ []byte, err error)

func (cd BaseColumn) GetDefaultValue() string

func (cd BaseColumn) GetIsAutoIncrement() bool

func (cd BaseColumn) GetIsIdentity() bool

func (cd BaseColumn) GetIsNullable() bool

func (cd BaseColumn) GetName() string

func (cd BaseColumn) GetSQLType() string

func (cd BaseColumn) GetVarcharLen() int

type BaseDatabase ¶

type BaseDatabase struct {
	Tables      []Table
	ForeignKeys map[ForeignKey]string
}

BaseDatabase is a base database definition.

Dialects and only dialects can use it to implement the Database interface. Other packages must use the Database interface.

func (ds BaseDatabase) GetForeignKeys() map[ForeignKey]string

func (ds BaseDatabase) GetTables() []Table

type BaseMigrator ¶

type BaseMigrator struct {
	// contains filtered or unexported fields
}

BaseMigrator can be embeded by dialect's Migrator implementations to re-use some of the existing bun queries.

func NewBaseMigrator(db *bun.DB) *BaseMigrator

func (m *BaseMigrator) AppendCreateTable(b []byte, model any) ([]byte, error)

func (m *BaseMigrator) AppendDropTable(b []byte, schemaName, tableName string) ([]byte, error)

type BaseTable ¶

type BaseTable struct {
	Schema string
	Name   string

	// ColumnDefinitions map each column name to the column definition.
	Columns []Column

	// PrimaryKey holds the primary key definition.
	// A nil value means that no primary key is defined for the table.
	PrimaryKey *PrimaryKey

	// UniqueConstraints defined on the table.
	UniqueConstraints []Unique
}

BaseTable is a base table definition.

Dialects and only dialects can use it to implement the Table interface. Other packages must use the Table interface.

func (td *BaseTable) GetColumns() []Column

func (td *BaseTable) GetName() string

func (td *BaseTable) GetPrimaryKey() *PrimaryKey

func (td *BaseTable) GetSchema() string

func (td *BaseTable) GetUniqueConstraints() []Unique

type BunModelInspector ¶

type BunModelInspector struct {
	InspectorConfig
	// contains filtered or unexported fields
}

BunModelInspector creates the current project state from the passed bun.Models. Do not recycle BunModelInspector for different sets of models, as older models will not be de-registerred before the next run.

BunModelInspector does not know which the database's dialect, so it does not assume any default schema name. Always specify the target schema name via WithSchemaName option to receive meaningful results.

func NewBunModelInspector(tables *schema.Tables, options ...InspectorOption) *BunModelInspector

func (bmi *BunModelInspector) Inspect(ctx context.Context) (Database, error)

type BunModelSchema ¶

type BunModelSchema struct {
	BaseDatabase

	Tables []Table
}

BunModelSchema is the schema state derived from bun table models.

func (ms BunModelSchema) GetTables() []Table

type BunTable ¶

type BunTable struct {
	BaseTable

	// Model stores the zero interface to the underlying Go struct.
	Model any
}

BunTable provides additional table metadata that is only accessible from scanning bun models.

type Column ¶

type Column interface {
	GetName() string
	GetSQLType() string
	GetVarcharLen() int
	GetDefaultValue() string
	GetIsNullable() bool
	GetIsAutoIncrement() bool
	GetIsIdentity() bool
	AppendQuery(schema.QueryGen, []byte) ([]byte, error)
}

type ColumnReference ¶

type ColumnReference struct {
	TableName string
	Column    Columns
}

func NewColumnReference(tableName string, columns ...string) ColumnReference

type Columns ¶

type Columns string

Columns is a hashable representation of []string used to define schema constraints that depend on multiple columns. Although having duplicated column references in these constraints is illegal, Columns neither validates nor enforces this constraint on the caller.

func NewColumns(columns ...string) Columns

func (c *Columns) AppendQuery(gen schema.QueryGen, b []byte) ([]byte, error)

func (c *Columns) Contains(other string) bool

func (c *Columns) ContainsColumns(other Columns) bool

func (c *Columns) Replace(oldColumn, newColumn string) bool

func (c *Columns) Split() []string

func (c *Columns) String() string

type Database ¶

type Database interface {
	GetTables() []Table
	GetForeignKeys() map[ForeignKey]string
}

type ForeignKey ¶

type ForeignKey struct {
	From ColumnReference
	To   ColumnReference
}

func (fk ForeignKey) DependsOnColumn(tableName string, column string) bool

func (fk ForeignKey) DependsOnTable(tableName string) bool

type Inspector ¶

type Inspector interface {
	Inspect(ctx context.Context) (Database, error)
}

Inspector reads schema state.

func NewInspector(db *bun.DB, options ...InspectorOption) (Inspector, error)

type InspectorConfig ¶

type InspectorConfig struct {
	// SchemaName limits inspection to tables in a particular schema.
	SchemaName string

	// ExcludeTables from inspection. Patterns MAY make use of wildcards
	// like % and _ and dialects MUST acknowledge that by using them
	// with the SQL LIKE operator.
	ExcludeTables []string

	// ExcludeForeignKeys from inspection.
	ExcludeForeignKeys map[ForeignKey]string
}

InspectorConfig controls the scope of migration by limiting the objects Inspector should return. Inspectors SHOULD use the configuration directly instead of copying it, or MAY choose to embed it, to make sure options are always applied correctly.

ExcludeTables and ExcludeForeignKeys are intended for database inspectors, to compensate for the fact that model structs may not wholly reflect the state of the database schema. Database inspectors MUST respect these exclusions to prevent relations from being dropped unintentionally.

type InspectorDialect ¶

type InspectorDialect interface {
	schema.Dialect

	// Inspector returns a new instance of Inspector for the dialect.
	// Dialects MAY set their default InspectorConfig values in constructor
	// but MUST apply InspectorOptions to ensure they can be overriden.
	//
	// Use ApplyInspectorOptions to reduce boilerplate.
	NewInspector(db *bun.DB, options ...InspectorOption) Inspector

	// CompareType returns true if col1 and co2 SQL types are equivalent,
	// i.e. they might use dialect-specifc type aliases (SERIAL ~ SMALLINT)
	// or specify the same VARCHAR length differently (VARCHAR(255) ~ VARCHAR).
	CompareType(Column, Column) bool
}

type InspectorOption ¶

type InspectorOption func(*InspectorConfig)

func WithExcludeForeignKeys(fks ...ForeignKey) InspectorOption

func WithExcludeTables(tables ...string) InspectorOption

func WithSchemaName(schemaName string) InspectorOption

type Migrator ¶

type Migrator interface {
	AppendSQL(b []byte, operation any) ([]byte, error)
}

func NewMigrator(db *bun.DB, schemaName string) (Migrator, error)

type MigratorDialect ¶

type MigratorDialect interface {
	schema.Dialect
	NewMigrator(db *bun.DB, schemaName string) Migrator
}

type PrimaryKey ¶

type PrimaryKey struct {
	Name    string
	Columns Columns
}

PrimaryKey represents a primary key constraint defined on 1 or more columns.

type Table ¶

type Table interface {
	GetSchema() string
	GetName() string
	GetColumns() []Column
	GetPrimaryKey() *PrimaryKey
	GetUniqueConstraints() []Unique
}

type Unique ¶

type Unique struct {
	Name    string
	Columns Columns
}

Unique represents a unique constraint defined on 1 or more columns.

func (u Unique) Equals(other Unique) bool