schema

type AddAttr ¶

type AddAttr struct {
	A Attr
}

AddAttr describes an attribute addition.

type AddCheck ¶

type AddCheck struct {
	C *Check
}

AddCheck describes a CHECK constraint creation change.

type AddColumn ¶

type AddColumn struct {
	C *Column
}

AddColumn describes a column creation change.

type AddForeignKey ¶

type AddForeignKey struct {
	F *ForeignKey
}

AddForeignKey describes a foreign-key creation change.

type AddFunc ¶

type AddFunc struct {
	F     *Func
	Extra []Clause // Extra clauses and options.
}

AddFunc describes a function creation change.

type AddIndex ¶

type AddIndex struct {
	I     *Index
	Extra []Clause // Extra clauses and options.
}

AddIndex describes an index creation change.

type AddObject ¶

type AddObject struct {
	O     Object
	Extra []Clause // Extra clauses and options.
}

AddObject describes a generic object creation change.

type AddPrimaryKey ¶

type AddPrimaryKey struct {
	P *Index
}

AddPrimaryKey describes a primary-key creation change.

type AddProc ¶

type AddProc struct {
	P     *Proc
	Extra []Clause // Extra clauses and options.
}

AddProc describes a procedure creation change.

type AddSchema ¶

type AddSchema struct {
	S     *Schema
	Extra []Clause // Extra clauses and options.
}

AddSchema describes a schema (named database) creation change. Unlike table creation, schemas and their elements are described with separate changes. For example, "AddSchema" and "AddTable"

type AddTable ¶

type AddTable struct {
	T     *Table
	Extra []Clause // Extra clauses and options.
}

AddTable describes a table creation change.

type AddTrigger ¶

type AddTrigger struct {
	T     *Trigger
	Extra []Clause // Extra clauses and options.
}

AddTrigger describes a trigger creation change.

type AddView ¶

type AddView struct {
	V     *View
	Extra []Clause // Extra clauses and options.
}

AddView describes a view creation change.

type Attr ¶

type Attr interface {
	// contains filtered or unexported methods
}

Attr represents the interface that all attributes implement.

func RemoveAttr[T Attr](attrs []Attr) []Attr

type BinaryOption ¶

type BinaryOption func(*BinaryType)

BinaryOption allows configuring BinaryType using functional options.

func BinarySize(size int) BinaryOption

type BinaryType ¶

type BinaryType struct {
	T    string
	Size *int
}

BinaryType represents a type that stores a binary data.

type BoolType ¶

type BoolType struct {
	T string
}

BoolType represents a boolean type.

type Change ¶

type Change interface {
	// contains filtered or unexported methods
}

A Change represents a schema change. The types below implement this interface and can be used for describing schema changes.

The Change interface can also be implemented outside this package as follows:

type RenameType struct {
	schema.Change
	From, To string
}

var t schema.Change = &RenameType{From: "old", To: "new"}

type ChangeKind ¶

type ChangeKind uint

A ChangeKind describes a change kind that can be combined using a set of flags. The zero kind is no change.

const (
	// NoChange holds the zero value of a change kind.
	NoChange ChangeKind = 0

	// ChangeAttr describes attributes change of an element.
	// For example, a table CHECK was added or changed.
	ChangeAttr ChangeKind = 1 << (iota - 1)
	// ChangeCharset describes character-set change.
	ChangeCharset
	// ChangeCollate describes collation/encoding change.
	ChangeCollate
	// ChangeComment describes comment chang (of any element).
	ChangeComment

	// ChangeNull describe a change to the NULL constraint.
	ChangeNull
	// ChangeType describe a column type change.
	ChangeType
	// ChangeDefault describe a column default change.
	ChangeDefault
	// ChangeGenerated describe a change to the generated expression.
	ChangeGenerated

	// ChangeUnique describes a change to the uniqueness constraint.
	// For example, an index was changed from non-unique to unique.
	ChangeUnique
	// ChangeParts describes a change to one or more of the index parts.
	// For example, index keeps its previous name, but the columns order
	// was changed.
	ChangeParts

	// ChangeColumn describes a change to the foreign-key (child) columns.
	ChangeColumn
	// ChangeRefColumn describes a change to the foreign-key (parent) columns.
	ChangeRefColumn
	// ChangeRefTable describes a change to the foreign-key (parent) table.
	ChangeRefTable
	// ChangeUpdateAction describes a change to the foreign-key update action.
	ChangeUpdateAction
	// ChangeDeleteAction describes a change to the foreign-key delete action.
	ChangeDeleteAction
)

func (k ChangeKind) Is(c ChangeKind) bool

func (i ChangeKind) String() string

type Changes ¶

type Changes []Change

Changes is a list of changes allow for searching and mutating changes.

func (c Changes) IndexAddColumn(name string) int

func (c Changes) IndexAddIndex(name string) int

func (c Changes) IndexAddTable(name string) int

func (c Changes) IndexDropColumn(name string) int

func (c Changes) IndexDropIndex(name string) int

func (c Changes) IndexDropTable(name string) int

func (c Changes) IndexModifyColumn(name string) int

func (c Changes) LastIndexAddTable(name string) int

func (c Changes) LastIndexDropTable(name string) int

func (c *Changes) RemoveIndex(indexes ...int)

type Charset ¶

type Charset struct {
	V string
}

Charset describes a column or a table character-set setting.

type Check ¶

type Check struct {
	Name  string // Optional constraint name.
	Expr  string // Actual CHECK.
	Attrs []Attr // Additional attributes (e.g. ENFORCED).
}

Check describes a CHECK constraint.

func NewCheck() *Check

func (c *Check) AddAttrs(attrs ...Attr) *Check

func (c *Check) SetExpr(expr string) *Check

func (c *Check) SetName(name string) *Check

type Clause ¶

type Clause interface {
	// contains filtered or unexported methods
}

Clause carries additional information that can be added to schema changes. The Clause interface can be implemented outside this package as follows:

type Authorization struct {
	schema.Clause
	UserName string
}

var c schema.Clause = &Authorization{UserName: "a8m"}

type Collation ¶

type Collation struct {
	V string
}

Collation describes a column or a table collation setting.

type Column ¶

type Column struct {
	Name    string
	Type    *ColumnType
	Default Expr
	Attrs   []Attr
	Indexes []*Index
	// Foreign keys that this column is
	// part of their child columns.
	ForeignKeys []*ForeignKey
}

A Column represents a column definition.

func NewBinaryColumn(name, typ string, opts ...BinaryOption) *Column

func NewBoolColumn(name, typ string) *Column

func NewColumn(name string) *Column

func NewDecimalColumn(name, typ string, opts ...DecimalOption) *Column

func NewEnumColumn(name string, opts ...EnumOption) *Column

func NewFloatColumn(name, typ string, opts ...FloatOption) *Column

func NewIntColumn(name, typ string) *Column

func NewJSONColumn(name, typ string) *Column

func NewNullBinaryColumn(name, typ string, opts ...BinaryOption) *Column

func NewNullBoolColumn(name, typ string) *Column

func NewNullColumn(name string) *Column

func NewNullDecimalColumn(name, typ string, opts ...DecimalOption) *Column

func NewNullEnumColumn(name string, opts ...EnumOption) *Column

func NewNullFloatColumn(name, typ string, opts ...FloatOption) *Column

func NewNullIntColumn(name, typ string) *Column

func NewNullJSONColumn(name, typ string) *Column

func NewNullSpatialColumn(name, typ string) *Column

func NewNullStringColumn(name, typ string, opts ...StringOption) *Column

func NewNullTimeColumn(name, typ string) *Column

func NewNullUintColumn(name, typ string) *Column

func NewSpatialColumn(name, typ string) *Column

func NewStringColumn(name, typ string, opts ...StringOption) *Column

func NewTimeColumn(name, typ string, opts ...TimeOption) *Column

func NewUintColumn(name, typ string) *Column

func (c *Column) AddAttrs(attrs ...Attr) *Column

func (c *Column) SetCharset(v string) *Column

func (c *Column) SetCollation(v string) *Column

func (c *Column) SetComment(v string) *Column

func (c *Column) SetDefault(x Expr) *Column

func (c *Column) SetGeneratedExpr(x *GeneratedExpr) *Column

func (c *Column) SetNull(b bool) *Column

func (c *Column) SetType(t Type) *Column

func (c *Column) UnsetCharset() *Column

func (c *Column) UnsetCollation() *Column

type ColumnType ¶

type ColumnType struct {
	Type Type
	Raw  string
	Null bool
}

ColumnType represents a column type that is implemented by the dialect.

type Comment ¶

type Comment struct {
	Text string
}

Comment describes a schema element comment.

type DecimalOption ¶

type DecimalOption func(*DecimalType)

DecimalOption allows configuring DecimalType using functional options.

func DecimalPrecision(precision int) DecimalOption

func DecimalScale(scale int) DecimalOption

func DecimalUnsigned(unsigned bool) DecimalOption

type DecimalType ¶

type DecimalType struct {
	T         string
	Precision int
	Scale     int
	Unsigned  bool
}

DecimalType represents a fixed-point type that stores exact numeric values.

type DiffOption ¶

type DiffOption func(*DiffOptions)

DiffOption allows configuring the DiffOptions using functional options.

func DiffSkipChanges(changes ...Change) DiffOption

DiffSkipChanges(&DropSchema{}, &DropTable{}, &DropColumn{}, &DropIndex{}, &DropForeignKey{})

type DiffOptions ¶

type DiffOptions struct {
	// SkipChanges defines a list of change types to skip.
	SkipChanges []Change

	// Extra defines per-driver configuration. If not
	// nil, should be set to schemahcl.Extension.
	Extra any // avoid circular dependency with schemahcl.
}

DiffOptions defines the standard and per-driver configuration for the schema diffing process.

func NewDiffOptions(opts ...DiffOption) *DiffOptions

func (o *DiffOptions) AddOrSkip(changes Changes, cs ...Change) Changes

func (o *DiffOptions) Skipped(c Change) bool

type Differ ¶

type Differ interface {
	// RealmDiff returns a diff report for migrating a realm
	// (or a database) from state "from" to state "to". An error
	// is returned if such step is not possible.
	RealmDiff(from, to *Realm, opts ...DiffOption) ([]Change, error)

	// SchemaDiff returns a diff report for migrating a schema
	// from state "from" to state "to". An error is returned
	// if such step is not possible.
	SchemaDiff(from, to *Schema, opts ...DiffOption) ([]Change, error)

	// TableDiff returns a diff report for migrating a table
	// from state "from" to state "to". An error is returned
	// if such step is not possible.
	TableDiff(from, to *Table, opts ...DiffOption) ([]Change, error)
}

Differ is the interface implemented by the different drivers for comparing and diffing schema top elements.

type DropAttr ¶

type DropAttr struct {
	A Attr
}

DropAttr describes an attribute removal.

type DropCheck ¶

type DropCheck struct {
	C *Check
}

DropCheck describes a CHECK constraint removal change.

type DropColumn ¶

type DropColumn struct {
	C *Column
}

DropColumn describes a column removal change.

type DropForeignKey ¶

type DropForeignKey struct {
	F *ForeignKey
}

DropForeignKey describes a foreign-key removal change.

type DropFunc ¶

type DropFunc struct {
	F     *Func
	Extra []Clause // Extra clauses.
}

DropFunc describes a function removal change.

type DropIndex ¶

type DropIndex struct {
	I     *Index
	Extra []Clause // Extra clauses and options.
}

DropIndex describes an index removal change.

type DropObject ¶

type DropObject struct {
	O     Object
	Extra []Clause // Extra clauses.
}

DropObject describes a generic object removal change.

type DropPrimaryKey ¶

type DropPrimaryKey struct {
	P *Index
}

DropPrimaryKey describes a primary-key removal change.

type DropProc ¶

type DropProc struct {
	P     *Proc
	Extra []Clause // Extra clauses.
}

DropProc describes a procedure removal change.

type DropSchema ¶

type DropSchema struct {
	S     *Schema
	Extra []Clause // Extra clauses and options.
}

DropSchema describes a schema (named database) removal change.

type DropTable ¶

type DropTable struct {
	T     *Table
	Extra []Clause // Extra clauses.
}

DropTable describes a table removal change.

type DropTrigger ¶

type DropTrigger struct {
	T     *Trigger
	Extra []Clause // Extra clauses.
}

DropTrigger describes a trigger removal change.

type DropView ¶

type DropView struct {
	V     *View
	Extra []Clause // Extra clauses.
}

DropView describes a view removal change.

type EnumOption ¶

type EnumOption func(*EnumType)

EnumOption allows configuring EnumType using functional options.

func EnumName(name string) EnumOption

func EnumSchema(s *Schema) EnumOption

func EnumValues(values ...string) EnumOption

type EnumType ¶

type EnumType struct {
	T      string   // Optional type.
	Values []string // Enum values.
	Schema *Schema  // Optional schema.
}

EnumType represents an enum type.

func (e *EnumType) SpecName() string

func (e *EnumType) SpecType() string

type ExecQuerier ¶

type ExecQuerier interface {
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}

ExecQuerier wraps the two standard sql.DB methods.

type Expr ¶

type Expr interface {
	// contains filtered or unexported methods
}

Expr defines an SQL expression in schema DDL.

The Expr interface can also be implemented outside this package as follows:

	type NamedDefault struct {
		schema.Expr
		Name string
	}
	// Underlying returns the underlying expression.
	func (e *NamedDefault) Underlying() schema.Expr { return e.Expr }

 var e schema.Expr = &NamedDefault{Expr: &schema.Literal{V: "bar"}, Name: "foo"}

func UnderlyingExpr(x Expr) Expr

type FloatOption ¶

type FloatOption func(*FloatType)

FloatOption allows configuring FloatType using functional options.

func FloatPrecision(precision int) FloatOption

func FloatUnsigned(unsigned bool) FloatOption

type FloatType ¶

type FloatType struct {
	T         string
	Unsigned  bool
	Precision int
}

FloatType represents a floating-point type that stores approximate numeric values.

type ForeignKey ¶

type ForeignKey struct {
	Symbol     string
	Table      *Table
	Columns    []*Column
	RefTable   *Table
	RefColumns []*Column
	OnUpdate   ReferenceOption
	OnDelete   ReferenceOption
}

A ForeignKey represents an index definition.

func NewForeignKey(symbol string) *ForeignKey

func (f *ForeignKey) AddColumns(columns ...*Column) *ForeignKey

func (f *ForeignKey) AddRefColumns(columns ...*Column) *ForeignKey

func (f *ForeignKey) Column(name string) (*Column, bool)

func (f *ForeignKey) RefColumn(name string) (*Column, bool)

func (f *ForeignKey) SetOnDelete(o ReferenceOption) *ForeignKey

func (f *ForeignKey) SetOnUpdate(o ReferenceOption) *ForeignKey

func (f *ForeignKey) SetRefTable(t *Table) *ForeignKey

func (f *ForeignKey) SetTable(t *Table) *ForeignKey

type Func ¶

type Func struct {
	Name   string
	Schema *Schema
	Args   []*FuncArg
	Ret    Type
	Body   string   // Function body only.
	Lang   string   // Language (e.g. SQL, PL/pgSQL, etc.).
	Attrs  []Attr   // Extra driver specific attributes.
	Deps   []Object // Objects this function depends on.
}

Func represents a function definition.

func (f *Func) AddDeps(objs ...Object) *Func

type FuncArg ¶

type FuncArg struct {
	Name    string      // Optional name.
	Type    Type        // Argument type.
	Default Expr        // Default value.
	Mode    FuncArgMode // Argument mode.
	Attrs   []Attr      // Extra driver specific attributes.
}

A FuncArg represents a single function argument.

type FuncArgMode ¶

type FuncArgMode string

FuncArgMode represents a function argument mode.

const (
	FuncArgModeIn       FuncArgMode = "IN"
	FuncArgModeOut      FuncArgMode = "OUT"
	FuncArgModeInOut    FuncArgMode = "INOUT"
	FuncArgModeVariadic FuncArgMode = "VARIADIC"
)

type GeneratedExpr ¶

type GeneratedExpr struct {
	Expr string
	Type string // Optional type. e.g. STORED or VIRTUAL.
}

GeneratedExpr describes the expression used for generating the value of a generated/virtual column.

type IfExists ¶

type IfExists struct{}

IfExists represents a clause in a schema change that is commonly supported by multiple statements (e.g. DROP TABLE or DROP SCHEMA).

type IfNotExists ¶

type IfNotExists struct{}

IfNotExists represents a clause in a schema change that is commonly supported by multiple statements (e.g. CREATE TABLE or CREATE SCHEMA).

type Index ¶

type Index struct {
	Name   string
	Unique bool
	// Table or View that this index belongs to.
	Table *Table
	View  *View
	Attrs []Attr
	Parts []*IndexPart
}

An Index represents an index definition.

func NewIndex(name string) *Index

func NewPrimaryKey(columns ...*Column) *Index

func NewUniqueIndex(name string) *Index

func (i *Index) AddAttrs(attrs ...Attr) *Index

func (i *Index) AddColumns(columns ...*Column) *Index

func (i *Index) AddExprs(exprs ...Expr) *Index

func (i *Index) AddParts(parts ...*IndexPart) *Index

func (i *Index) SetComment(v string) *Index

func (i *Index) SetName(name string) *Index

func (i *Index) SetTable(t *Table) *Index

func (i *Index) SetUnique(b bool) *Index

type IndexPart ¶

type IndexPart struct {
	// SeqNo represents the sequence number of the key part
	// in the index.
	SeqNo int
	// Desc indicates if the key part is stored in descending
	// order. All databases use ascending order as default.
	Desc  bool
	X     Expr
	C     *Column
	Attrs []Attr
}

An IndexPart represents an index part that can be either an expression or a column.

func NewColumnPart(c *Column) *IndexPart

func NewExprPart(x Expr) *IndexPart

func NewIndexPart() *IndexPart

func (p *IndexPart) AddAttrs(attrs ...Attr) *IndexPart

func (p *IndexPart) SetColumn(c *Column) *IndexPart

func (p *IndexPart) SetDesc(b bool) *IndexPart

func (p *IndexPart) SetExpr(x Expr) *IndexPart

type InspectMode ¶

type InspectMode uint

An InspectMode controls the amount and depth of information returned on inspection.

const (
	// InspectSchemas enables schema inspection.
	InspectSchemas InspectMode = 1 << iota

	// InspectTables enables schema tables inspection including
	// all its child resources (e.g. columns or indexes).
	InspectTables

	// InspectViews enables schema views inspection.
	InspectViews

	// InspectFuncs enables schema functions / procedures inspection.
	InspectFuncs

	// InspectTypes enables schema types inspection.
	InspectTypes

	// InspectObjects enables inspection of database specific
	// objects like sequences and extensions.
	InspectObjects

	// InspectTriggers enables schema triggers inspection.
	InspectTriggers
)

func (m InspectMode) Is(i InspectMode) bool

type InspectOptions ¶

type InspectOptions struct {
	// Mode defines the amount of information returned by InspectSchema.
	// If zero, InspectSchema inspects whole resources in the schema.
	Mode InspectMode

	// Tables to inspect. Empty means all tables in the schema.
	Tables []string

	// Exclude defines a list of glob patterns used to filter resources from inspection.
	// The syntax used by the different drivers is implemented as follows:
	//
	//	t   // exclude table 't'.
	//	*   // exclude all tables.
	//	t.c // exclude column, index and foreign-key named 'c' in table 't'.
	//	t.* // the last item defines the filtering; all resources under 't' are excluded.
	//	*.c // the last item defines the filtering; all resourced named 'c' are excluded in all tables.
	//	*.* // the last item defines the filtering; all resourced under all tables are excluded.
	//
	Exclude []string
}

InspectOptions describes options for Inspector.

type InspectRealmOption ¶

type InspectRealmOption struct {
	// Mode defines the amount of information returned by InspectRealm.
	// If zero, InspectRealm inspects all schemas and their child resources.
	Mode InspectMode

	// Schemas to inspect. Empty means all schemas in the realm.
	Schemas []string

	// Exclude defines a list of glob patterns used to filter resources from inspection.
	// The syntax used by the different drivers is implemented as follows:
	//
	//	s     // exclude schema 's'.
	//	*     // exclude all schemas.
	//	s.t   // exclude table 't' under schema 's'.
	//	s.*   // the last item defines the filtering; all tables under 's' are excluded.
	//	*.t   // the last item defines the filtering; all tables named 't' are excluded in all schemas.
	//	*.*   // the last item defines the filtering; all tables under all schemas are excluded.
	//	*.*.c // the last item defines the filtering; all resourced named 'c' are excluded in all tables.
	//	*.*.* // the last item defines the filtering; all resources are excluded in all tables.
	//
	Exclude []string
}

InspectRealmOption describes options for RealmInspector.

type Inspector ¶

type Inspector interface {
	// InspectSchema returns the schema description by its name. An empty name means the
	// "attached schema" (e.g. SCHEMA() in MySQL or CURRENT_SCHEMA() in PostgreSQL).
	// A NotExistError error is returned if the schema does not exist in the database.
	InspectSchema(ctx context.Context, name string, opts *InspectOptions) (*Schema, error)

	// InspectRealm returns the description of the connected database.
	InspectRealm(ctx context.Context, opts *InspectRealmOption) (*Realm, error)
}

Inspector is the interface implemented by the different database drivers for inspecting schema or databases.

type IntegerType ¶

type IntegerType struct {
	T        string
	Unsigned bool
	Attrs    []Attr
}

IntegerType represents an int type.

type JSONType ¶

type JSONType struct {
	T string
}

JSONType represents a JSON type.

type Literal ¶

type Literal struct {
	V string
}

Literal represents a basic literal expression like 1, or '1'. String literals are usually quoted with single or double quotes.

type Locker ¶

type Locker interface {
	// Lock acquires a named "advisory lock", using the given timeout. Negative value means no timeout,
	// and the zero value means a "try lock" mode. i.e. return immediately if the lock is already taken.
	// The returned unlock function is used to release the advisory lock acquired by the session.
	//
	// An ErrLocked is returned if the operation failed to obtain the lock in all different timeout modes.
	Lock(ctx context.Context, name string, timeout time.Duration) (UnlockFunc, error)
}

Locker is an interface that is optionally implemented by the different drivers for obtaining an "advisory lock" with the given name.

type Materialized ¶

type Materialized struct {
	Attr
}

Materialized is a schema attribute that attached to views to indicates they are MATERIALIZED VIEWs.

type ModifyAttr ¶

type ModifyAttr struct {
	From, To Attr
}

ModifyAttr describes a change that modifies an element attribute.

type ModifyCheck ¶

type ModifyCheck struct {
	From, To *Check
	Change   ChangeKind
}

ModifyCheck describes a change that modifies a check.

type ModifyColumn ¶

type ModifyColumn struct {
	From, To *Column
	Change   ChangeKind
}

ModifyColumn describes a change that modifies a column.

type ModifyForeignKey ¶

type ModifyForeignKey struct {
	From, To *ForeignKey
	Change   ChangeKind
}

ModifyForeignKey describes a change that modifies a foreign-key.

type ModifyFunc ¶

type ModifyFunc struct {
	From, To *Func
	// Changes that are extra to the function definition.
	// For example, adding, dropping, or modifying attributes.
	Changes []Change
}

ModifyFunc describes a function modification change.

type ModifyIndex ¶

type ModifyIndex struct {
	From, To *Index
	Change   ChangeKind
}

ModifyIndex describes an index modification.

type ModifyObject ¶

type ModifyObject struct {
	From, To Object
}

ModifyObject describes a generic object modification change. Unlike tables changes, the diffing types are implemented by the underlying driver.

type ModifyPrimaryKey ¶

type ModifyPrimaryKey struct {
	From, To *Index
	Change   ChangeKind
}

ModifyPrimaryKey describes a primary-key modification.

type ModifyProc ¶

type ModifyProc struct {
	From, To *Proc
	// Changes that are extra to the procedure definition.
	// For example, adding, dropping, or modifying attributes.
	Changes []Change
}

ModifyProc describes a procedure modification change.

type ModifySchema ¶

type ModifySchema struct {
	S       *Schema
	Changes []Change
}

ModifySchema describes a modification change for schema attributes.

type ModifyTable ¶

type ModifyTable struct {
	T       *Table
	Changes []Change
}

ModifyTable describes a table modification change.

type ModifyTrigger ¶

type ModifyTrigger struct {
	From, To *Trigger
	// Changes that are extra to the trigger definition.
	// For example, adding, dropping, or modifying attributes.
	Changes []Change
}

ModifyTrigger describes a trigger modification change.

type ModifyView ¶

type ModifyView struct {
	From, To *View
	// Changes that are extra to the view definition.
	// For example, adding or dropping indexes.
	Changes []Change
}

ModifyView describes a view modification change.

type Normalizer ¶

type Normalizer interface {
	// NormalizeSchema returns the normal representation of a schema.
	NormalizeSchema(context.Context, *Schema) (*Schema, error)

	// NormalizeRealm returns the normal representation of a database.
	NormalizeRealm(context.Context, *Realm) (*Realm, error)
}

Normalizer is the interface implemented by the different database drivers for "normalizing" schema objects. i.e. converting schema objects defined in natural form to their representation in the database. Thus, two schema objects are equal if their normal forms are equal.

type NotExistError ¶

type NotExistError struct {
	Err error
}

A NotExistError wraps another error to retain its original text but makes it possible to the migrator to catch it.

func (e NotExistError) Error() string

type Object ¶

type Object interface {
	// contains filtered or unexported methods
}

An Object represents a generic database object. Note that this interface is implemented by some top-level types to describe their relationship, and by driver specific types.

type Proc ¶

type Proc struct {
	Name   string
	Schema *Schema
	Args   []*FuncArg
	Body   string   // Function body only.
	Lang   string   // Language (e.g. SQL, PL/pgSQL, etc.).
	Attrs  []Attr   // Extra driver specific attributes.
	Deps   []Object // Objects this function depends on.
}

Proc represents a procedure definition.

func (p *Proc) AddDeps(objs ...Object) *Proc

type RawExpr ¶

type RawExpr struct {
	X string
}

RawExpr represents a raw expression like "uuid()" or "current_timestamp()". Unlike literals, raw expression are usually inlined as is on migration.

type Realm ¶

type Realm struct {
	Schemas []*Schema
	Attrs   []Attr
	Objects []Object // Realm-level objects (e.g., users or extensions).
}

A Realm or a database describes a domain of schema resources that are logically connected and can be accessed and queried in the same connection (e.g. a physical database instance).

func ExcludeRealm(r *Realm, patterns []string) (*Realm, error)

func NewRealm(schemas ...*Schema) *Realm

func (r *Realm) AddObjects(objs ...Object) *Realm

func (r *Realm) AddSchemas(schemas ...*Schema) *Realm

func (r *Realm) Object(f func(Object) bool) (Object, bool)

func (r *Realm) Schema(name string) (*Schema, bool)

func (r *Realm) SetCharset(v string) *Realm

func (r *Realm) SetCollation(v string) *Realm

func (r *Realm) UnsetCharset() *Realm

func (r *Realm) UnsetCollation() *Realm

type ReferenceOption ¶

type ReferenceOption string

ReferenceOption for constraint actions.

const (
	NoAction   ReferenceOption = "NO ACTION"
	Restrict   ReferenceOption = "RESTRICT"
	Cascade    ReferenceOption = "CASCADE"
	SetNull    ReferenceOption = "SET NULL"
	SetDefault ReferenceOption = "SET DEFAULT"
)

type RenameColumn ¶

type RenameColumn struct {
	From, To *Column
}

RenameColumn describes a column rename change.

type RenameFunc ¶

type RenameFunc struct {
	From, To *Func
}

RenameFunc describes a function rename change.

type RenameIndex ¶

type RenameIndex struct {
	From, To *Index
}

RenameIndex describes an index rename change.

type RenameObject ¶

type RenameObject struct {
	From, To Object
}

RenameObject describes a generic object rename change.

type RenameProc ¶

type RenameProc struct {
	From, To *Proc
}

RenameProc describes a procedure rename change.

type RenameTable ¶

type RenameTable struct {
	From, To *Table
}

RenameTable describes a table rename change.

type RenameTrigger ¶

type RenameTrigger struct {
	From, To *Trigger
}

RenameTrigger describes a trigger rename change.

type RenameView ¶

type RenameView struct {
	From, To *View
}

RenameView describes a view rename change.

type Schema ¶

type Schema struct {
	Name    string
	Realm   *Realm
	Tables  []*Table
	Views   []*View
	Funcs   []*Func
	Procs   []*Proc
	Attrs   []Attr   // Attrs and options.
	Objects []Object // Schema-level objects (e.g., types or sequences).
}

A Schema describes a database schema (i.e. named database).

func ExcludeSchema(s *Schema, patterns []string) (*Schema, error)

func New(name string) *Schema

func (s *Schema) AddAttrs(attrs ...Attr) *Schema

func (s *Schema) AddFuncs(funcs ...*Func) *Schema

func (s *Schema) AddObjects(objs ...Object) *Schema

func (s *Schema) AddProcs(procs ...*Proc) *Schema

func (s *Schema) AddTables(tables ...*Table) *Schema

func (s *Schema) AddViews(views ...*View) *Schema

func (s *Schema) Func(name string) (*Func, bool)

func (s *Schema) Materialized(name string) (*View, bool)

func (s *Schema) Object(f func(Object) bool) (Object, bool)

func (s *Schema) Proc(name string) (*Proc, bool)

func (s *Schema) SetCharset(v string) *Schema

func (s *Schema) SetCollation(v string) *Schema

func (s *Schema) SetComment(v string) *Schema

func (s *Schema) SetRealm(r *Realm) *Schema

func (s *Schema) Table(name string) (*Table, bool)

func (s *Schema) UnsetCharset() *Schema

func (s *Schema) UnsetCollation() *Schema

func (s *Schema) View(name string) (*View, bool)

type SpatialType ¶

type SpatialType struct {
	T string
}

SpatialType represents a spatial/geometric type.

type StringOption ¶

type StringOption func(*StringType)

StringOption allows configuring StringType using functional options.

func StringSize(size int) StringOption

type StringType ¶

type StringType struct {
	T     string
	Size  int
	Attrs []Attr
}

StringType represents a string type.

type Table ¶

type Table struct {
	Name        string
	Schema      *Schema
	Columns     []*Column
	Indexes     []*Index
	PrimaryKey  *Index
	ForeignKeys []*ForeignKey
	Attrs       []Attr     // Attrs, constraints and options.
	Triggers    []*Trigger // Triggers on the table.
	Deps        []Object   // Objects this table depends on.
}

A Table represents a table definition.

func NewTable(name string) *Table

func (t *Table) AddAttrs(attrs ...Attr) *Table

func (t *Table) AddChecks(checks ...*Check) *Table

func (t *Table) AddColumns(columns ...*Column) *Table

func (t *Table) AddDeps(objs ...Object) *Table

func (t *Table) AddForeignKeys(fks ...*ForeignKey) *Table

func (t *Table) AddIndexes(indexes ...*Index) *Table

func (t *Table) Column(name string) (*Column, bool)

func (t *Table) ForeignKey(symbol string) (*ForeignKey, bool)

func (t *Table) Index(name string) (*Index, bool)

func (t *Table) SetCharset(v string) *Table

func (t *Table) SetCollation(v string) *Table

func (t *Table) SetComment(v string) *Table

func (t *Table) SetPrimaryKey(pk *Index) *Table

func (t *Table) SetSchema(s *Schema) *Table

func (t *Table) Trigger(name string) (*Trigger, bool)

func (t *Table) UnsetCharset() *Table

func (t *Table) UnsetCollation() *Table

type TimeOption ¶

type TimeOption func(*TimeType)

TimeOption allows configuring TimeType using functional options.

func TimePrecision(precision int) TimeOption

func TimeScale(scale int) TimeOption

type TimeType ¶

type TimeType struct {
	T         string
	Precision *int
	Scale     *int
	Attrs     []Attr
}

TimeType represents a date/time type.

type Trigger ¶

type Trigger struct {
	Name string
	// Table or View that this trigger belongs to.
	Table      *Table
	View       *View
	ActionTime TriggerTime    // BEFORE, AFTER, or INSTEAD OF.
	Events     []TriggerEvent // INSERT, UPDATE, DELETE, etc.
	For        TriggerFor     // FOR EACH ROW or FOR EACH STATEMENT.
	Body       string         // Trigger body only.
	Attrs      []Attr         // WHEN, REFERENCING, etc.
	Deps       []Object       // Objects this trigger depends on.
}

A Trigger represents a trigger definition.

type TriggerEvent ¶

type TriggerEvent struct {
	Name    string    // Name of the event (e.g. INSERT, UPDATE, DELETE).
	Columns []*Column // Columns that might be associated with the event.
}

TriggerEvent represents the trigger event.

func TriggerEventUpdateOf(columns ...*Column) TriggerEvent

type TriggerFor ¶

type TriggerFor string

TriggerFor represents the trigger FOR EACH spec.

const (
	TriggerForRow  TriggerFor = "ROW"
	TriggerForStmt TriggerFor = "STATEMENT"
)

type TriggerTime ¶

type TriggerTime string

TriggerTime represents the trigger action time.

const (
	TriggerTimeBefore  TriggerTime = "BEFORE"
	TriggerTimeAfter   TriggerTime = "AFTER"
	TriggerTimeInstead TriggerTime = "INSTEAD OF"
)

type Type ¶

type Type interface {
	// contains filtered or unexported methods
}

A Type represents a database type. The types below implements this interface and can be used for describing schemas.

The Type interface can also be implemented outside this package as follows:

type SpatialType struct {
	schema.Type
	T string
}

var t schema.Type = &SpatialType{T: "point"}

func UnderlyingType(t Type) Type

type TypeFormatter ¶

type TypeFormatter interface {
	// FormatType converts a schema type to its column form in the database.
	FormatType(Type) (string, error)
}

TypeFormatter is an interface that is required to be implemented by different drivers to format column types into their corresponding database forms.

type TypeParseFormatter ¶

type TypeParseFormatter interface {
	TypeParser
	TypeFormatter
}

TypeParseFormatter that groups the TypeParser and TypeFormatter interfaces.

type TypeParser ¶

type TypeParser interface {
	// ParseType converts the raw database type to its schema.Type representation.
	ParseType(string) (Type, error)
}

TypeParser is an interface that is required be implemented by different drivers for parsing column types from their database forms to the schema representation.

type UUIDType ¶

type UUIDType struct {
	T string
}

A UUIDType defines a UUID type.

type UnlockFunc ¶

type UnlockFunc func() error

UnlockFunc is returned by the Locker to explicitly release the named "advisory lock".

type UnsupportedType ¶

type UnsupportedType struct {
	T string
}

UnsupportedType represents a type that is not supported by the drivers.

type View ¶

type View struct {
	Name     string
	Def      string
	Schema   *Schema
	Columns  []*Column
	Attrs    []Attr     // Attrs and options.
	Indexes  []*Index   // Indexes on materialized view.
	Triggers []*Trigger // Triggers on the view.
	Deps     []Object   // Objects this view depends on.
}

A View represents a view definition.

func NewMaterializedView(name, def string) *View

func NewView(name, def string) *View

func (v *View) AddAttrs(attrs ...Attr) *View

func (v *View) AddColumns(columns ...*Column) *View

func (v *View) AddDeps(objs ...Object) *View

func (v *View) AddIndexes(indexes ...*Index) *View

func (v *View) AsTable() *Table

func (v *View) Column(name string) (*Column, bool)

func (v *View) Index(name string) (*Index, bool)

func (v *View) Materialized() bool

func (v *View) SetCheckOption(opt string) *View

func (v *View) SetComment(c string) *View

func (v *View) SetMaterialized(b bool) *View

func (v *View) SetSchema(s *Schema) *View

func (v *View) Trigger(name string) (*Trigger, bool)

type ViewCheckOption ¶

type ViewCheckOption struct {
	V string // LOCAL, CASCADED, NONE, or driver specific.
}

ViewCheckOption describes the standard 'WITH CHECK OPTION clause' of a view.