schema

package
v0.0.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 29, 2024 License: Apache-2.0 Imports: 11 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	ViewCheckOptionNone     = "NONE"
	ViewCheckOptionLocal    = "LOCAL"
	ViewCheckOptionCascaded = "CASCADED"
)

A list of known view check options.

Variables

View Source 
var (
	TriggerEventInsert   = TriggerEvent{Name: "INSERT"}
	TriggerEventUpdate   = TriggerEvent{Name: "UPDATE"}
	TriggerEventDelete   = TriggerEvent{Name: "DELETE"}
	TriggerEventTruncate = TriggerEvent{Name: "TRUNCATE"}
)

List of supported trigger events.

View Source 
var ErrLocked = errors.New("sql/schema: lock is held by other session")

ErrLocked is returned on Lock calls which have failed to obtain the lock.

Functions

func IsNotExistError 

func IsNotExistError(err error) bool

IsNotExistError reports if an error is a NotExistError.

func ReplaceOrAppend 

func ReplaceOrAppend(attrs *[]Attr, v Attr)

ReplaceOrAppend searches an attribute of the same type as v in the list and replaces it. Otherwise, v is appended to the list.

Types

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 

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

RemoveAttr returns a new slice where all attributes of type T are filtered.

type BinaryOption 

type BinaryOption func(*BinaryType)

BinaryOption allows configuring BinaryType using functional options.

func BinarySize 

func BinarySize(size int) BinaryOption

BinarySize configures the size of the binary type.

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 (ChangeKind) Is 

func (k ChangeKind) Is(c ChangeKind) bool

Is reports whether c is match the given change kind.

func (ChangeKind) String 

func (i ChangeKind) String() string

type Changes 

type Changes []Change

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

func (Changes) IndexAddColumn 

func (c Changes) IndexAddColumn(name string) int

IndexAddColumn returns the index of the first AddColumn in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexAddIndex 

func (c Changes) IndexAddIndex(name string) int

IndexAddIndex returns the index of the first AddIndex in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexAddTable 

func (c Changes) IndexAddTable(name string) int

IndexAddTable returns the index of the first AddTable in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexDropColumn 

func (c Changes) IndexDropColumn(name string) int

IndexDropColumn returns the index of the first DropColumn in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexDropIndex 

func (c Changes) IndexDropIndex(name string) int

IndexDropIndex returns the index of the first DropIndex in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexDropTable 

func (c Changes) IndexDropTable(name string) int

IndexDropTable returns the index of the first DropTable in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) IndexModifyColumn 

func (c Changes) IndexModifyColumn(name string) int

IndexModifyColumn returns the index of the first ModifyColumn in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) LastIndexAddTable 

func (c Changes) LastIndexAddTable(name string) int

LastIndexAddTable returns the index of the last AddTable in the changes with the given name, or -1 if there is no such change in the Changes.

func (Changes) LastIndexDropTable 

func (c Changes) LastIndexDropTable(name string) int

LastIndexDropTable returns the index of the last DropTable in the changes with the given name, or -1 if there is no such change in the Changes.

func (*Changes) RemoveIndex 

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

RemoveIndex removes elements in the given indexes from the Changes.

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 

func NewCheck() *Check

NewCheck creates a new check.

func (*Check) AddAttrs 

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

AddAttrs adds additional attributes to the check constraint.

func (*Check) SetExpr 

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

SetExpr configures the expression of the check constraint.

func (*Check) SetName 

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

SetName configures the name of the check constraint.

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 

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

NewBinaryColumn creates a new BinaryType column.

func NewBoolColumn 

func NewBoolColumn(name, typ string) *Column

NewBoolColumn creates a new BoolType column.

func NewColumn 

func NewColumn(name string) *Column

NewColumn creates a new column with the given name.

func NewDecimalColumn 

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

NewDecimalColumn creates a new DecimalType column.

func NewEnumColumn 

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

NewEnumColumn creates a new EnumType column.

func NewFloatColumn 

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

NewFloatColumn creates a new FloatType column.

func NewIntColumn 

func NewIntColumn(name, typ string) *Column

NewIntColumn creates a new IntegerType column.

func NewJSONColumn 

func NewJSONColumn(name, typ string) *Column

NewJSONColumn creates a new JSONType column.

func NewNullBinaryColumn 

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

NewNullBinaryColumn creates a new nullable BinaryType column.

func NewNullBoolColumn 

func NewNullBoolColumn(name, typ string) *Column

NewNullBoolColumn creates a new nullable BoolType column.

func NewNullColumn 

func NewNullColumn(name string) *Column

NewNullColumn creates a new nullable column with the given name.

func NewNullDecimalColumn 

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

NewNullDecimalColumn creates a new nullable DecimalType column.

func NewNullEnumColumn 

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

NewNullEnumColumn creates a new nullable EnumType column.

func NewNullFloatColumn 

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

NewNullFloatColumn creates a new nullable FloatType column.

func NewNullIntColumn 

func NewNullIntColumn(name, typ string) *Column

NewNullIntColumn creates a new nullable IntegerType column.

func NewNullJSONColumn 

func NewNullJSONColumn(name, typ string) *Column

NewNullJSONColumn creates a new nullable JSONType column.

func NewNullSpatialColumn 

func NewNullSpatialColumn(name, typ string) *Column

NewNullSpatialColumn creates a new nullable SpatialType column.

func NewNullStringColumn 

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

NewNullStringColumn creates a new nullable StringType column.

func NewNullTimeColumn 

func NewNullTimeColumn(name, typ string) *Column

NewNullTimeColumn creates a new nullable TimeType column.

func NewNullUintColumn 

func NewNullUintColumn(name, typ string) *Column

NewNullUintColumn creates a new nullable unsigned IntegerType column.

func NewSpatialColumn 

func NewSpatialColumn(name, typ string) *Column

NewSpatialColumn creates a new SpatialType column.

func NewStringColumn 

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

NewStringColumn creates a new StringType column.

func NewTimeColumn 

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

NewTimeColumn creates a new TimeType column.

func NewUintColumn 

func NewUintColumn(name, typ string) *Column

NewUintColumn creates a new unsigned IntegerType column.

func (*Column) AddAttrs 

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

AddAttrs adds additional attributes to the column.

func (*Column) SetCharset 

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

SetCharset sets or appends the Charset attribute to the column with the given value.

func (*Column) SetCollation 

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

SetCollation sets or appends the Collation attribute to the column with the given value.

func (*Column) SetComment 

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

SetComment sets or appends the Comment attribute to the column with the given value.

func (*Column) SetDefault 

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

SetDefault configures the default of the column

func (*Column) SetGeneratedExpr 

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

SetGeneratedExpr sets or appends the GeneratedExpr attribute.

func (*Column) SetNull 

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

SetNull configures the nullability of the column

func (*Column) SetType 

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

SetType configures the type of the column

func (*Column) UnsetCharset 

func (c *Column) UnsetCharset() *Column

UnsetCharset unsets the Charset attribute.

func (*Column) UnsetCollation 

func (c *Column) UnsetCollation() *Column

UnsetCollation the Collation attribute.

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 

func DecimalPrecision(precision int) DecimalOption

DecimalPrecision configures the precision of the decimal type.

func DecimalScale 

func DecimalScale(scale int) DecimalOption

DecimalScale configures the scale of the decimal type.

func DecimalUnsigned 

func DecimalUnsigned(unsigned bool) DecimalOption

DecimalUnsigned configures the unsigned of the float type.

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 

func DiffSkipChanges(changes ...Change) DiffOption

DiffSkipChanges returns a DiffOption that skips the given change types. For example, in order to skip all destructive changes, use: 

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 

func NewDiffOptions(opts ...DiffOption) *DiffOptions

NewDiffOptions creates a new DiffOptions from the given configuration.

func (*DiffOptions) AddOrSkip 

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

AddOrSkip adds the given change to the list of changes if it is not skipped.

func (*DiffOptions) Skipped 

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

Skipped reports whether the given change should be skipped.

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 

func EnumName(name string) EnumOption

EnumName configures the name of the name. This option is useful for databases like PostgreSQL that supports user-defined types for enums.

func EnumSchema 

func EnumSchema(s *Schema) EnumOption

EnumSchema configures the schema of the enum.

func EnumValues 

func EnumValues(values ...string) EnumOption

EnumValues configures the values of the enum.

type EnumType 

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

EnumType represents an enum type.

func (*EnumType) SpecName 

func (e *EnumType) SpecName() string

SpecName returns the name of the spec.

func (*EnumType) SpecType 

func (e *EnumType) SpecType() string

SpecType returns the type of the spec.

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 

func UnderlyingExpr(x Expr) Expr

UnderlyingExpr returns the underlying expression of x.

type FloatOption 

type FloatOption func(*FloatType)

FloatOption allows configuring FloatType using functional options.

func FloatPrecision 

func FloatPrecision(precision int) FloatOption

FloatPrecision configures the precision of the float type.

func FloatUnsigned 

func FloatUnsigned(unsigned bool) FloatOption

FloatUnsigned configures the unsigned of the float type.

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 

func NewForeignKey(symbol string) *ForeignKey

NewForeignKey creates a new foreign-key with the given constraints/symbol name.

func (*ForeignKey) AddColumns 

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

AddColumns appends columns to the child-table columns.

func (*ForeignKey) AddRefColumns 

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

AddRefColumns appends columns to the parent-table columns.

func (*ForeignKey) Column 

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

Column returns the first column that matches the given name.

func (*ForeignKey) RefColumn 

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

RefColumn returns the first referenced column that matches the given name.

func (*ForeignKey) SetOnDelete 

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

SetOnDelete sets the ON DELETE constraint action.

func (*ForeignKey) SetOnUpdate 

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

SetOnUpdate sets the ON UPDATE constraint action.

func (*ForeignKey) SetRefTable 

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

SetRefTable configures the referenced/parent table.

func (*ForeignKey) SetTable 

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

SetTable configures the table that holds the foreign-key (child table).

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 (*Func) AddDeps 

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

AddDeps adds the given objects as dependencies to the function.

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"
)

List of supported function argument modes.

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 

func NewIndex(name string) *Index

NewIndex creates a new index with the given name.

func NewPrimaryKey 

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

NewPrimaryKey creates a new primary-key index for the given columns.

func NewUniqueIndex 

func NewUniqueIndex(name string) *Index

NewUniqueIndex creates a new unique index with the given name.

func (*Index) AddAttrs 

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

AddAttrs adds additional attributes to the index.

func (*Index) AddColumns 

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

AddColumns adds the columns to index parts.

func (*Index) AddExprs 

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

AddExprs adds the expressions to index parts.

func (*Index) AddParts 

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

AddParts appends the given parts.

func (*Index) SetComment 

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

SetComment sets or appends the Comment attribute to the index with the given value.

func (*Index) SetName 

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

SetName configures the name of the index.

func (*Index) SetTable 

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

SetTable configures the table of the index.

func (*Index) SetUnique 

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

SetUnique configures the uniqueness of the 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 

func NewColumnPart(c *Column) *IndexPart

NewColumnPart creates a new index part with the given column.

func NewExprPart 

func NewExprPart(x Expr) *IndexPart

NewExprPart creates a new index part with the given expression.

func NewIndexPart 

func NewIndexPart() *IndexPart

NewIndexPart creates a new index part.

func (*IndexPart) AddAttrs 

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

AddAttrs adds and additional attributes to the index-part.

func (*IndexPart) SetColumn 

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

SetColumn sets the column of the index-part.

func (*IndexPart) SetDesc 

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

SetDesc configures the "DESC" attribute of the key part.

func (*IndexPart) SetExpr 

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

SetExpr sets the expression of the index-part.

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 (InspectMode) Is 

func (m InspectMode) Is(i InspectMode) bool

Is reports whether the given mode is enabled.

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 (NotExistError) Error 

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 (*Proc) AddDeps 

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

AddDeps adds the given objects as dependencies to the procedure.

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
}

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 

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

ExcludeRealm filters resources in the realm based on the given patterns.

func NewRealm 

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

NewRealm creates a new Realm.

func (*Realm) AddSchemas 

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

AddSchemas adds and links the given schemas to the realm.

func (*Realm) Schema 

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

Schema returns the first schema that matched the given name.

func (*Realm) SetCharset 

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

SetCharset sets or appends the Charset attribute to the realm with the given value.

func (*Realm) SetCollation 

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

SetCollation sets or appends the Collation attribute to the realm with the given value.

func (*Realm) UnsetCharset 

func (r *Realm) UnsetCharset() *Realm

UnsetCharset unsets the Charset attribute.

func (*Realm) UnsetCollation 

func (r *Realm) UnsetCollation() *Realm

UnsetCollation the Collation attribute.

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"
)

Reference options (actions) specified by ON UPDATE and ON DELETE subclauses of the FOREIGN KEY clause.

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 // Driver specific objects.
}

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

func ExcludeSchema 

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

ExcludeSchema filters resources in the schema based on the given patterns.

func New 

func New(name string) *Schema

New creates a new Schema.

func (*Schema) AddAttrs 

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

AddAttrs adds additional attributes to the schema.

func (*Schema) AddFuncs 

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

AddFuncs appends the given functions to the schema.

func (*Schema) AddObjects 

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

AddObjects adds the given objects to the schema.

func (*Schema) AddProcs 

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

AddProcs appends the given procedures to the schema.

func (*Schema) AddTables 

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

AddTables adds and links the given tables to the schema.

func (*Schema) AddViews 

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

AddViews adds and links the given views to the schema.

func (*Schema) Func 

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

Func returns the first function that matched the given name.

func (*Schema) Materialized 

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

Materialized returns the first materialized view that matched the given name.

func (*Schema) Object 

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

Object returns the first object that matched the given predicate.

func (*Schema) Proc 

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

Proc returns the first procedure that matched the given name.

func (*Schema) SetCharset 

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

SetCharset sets or appends the Charset attribute to the schema with the given value.

func (*Schema) SetCollation 

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

SetCollation sets or appends the Collation attribute to the schema with the given value.

func (*Schema) SetComment 

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

SetComment sets or appends the Comment attribute to the schema with the given value.

func (*Schema) SetRealm 

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

SetRealm sets the database/realm of the schema.

func (*Schema) Table 

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

Table returns the first table that matched the given name.

func (*Schema) UnsetCharset 

func (s *Schema) UnsetCharset() *Schema

UnsetCharset unsets the Charset attribute.

func (*Schema) UnsetCollation 

func (s *Schema) UnsetCollation() *Schema

UnsetCollation the Collation attribute.

func (*Schema) View 

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

View returns the first view that matched the given name.

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 

func StringSize(size int) StringOption

StringSize configures the size of the string type.

type StringType 

type StringType struct {
	T    string
	Size int
}

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 

func NewTable(name string) *Table

NewTable creates a new Table.

func (*Table) AddAttrs 

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

AddAttrs adds and additional attributes to the table.

func (*Table) AddChecks 

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

AddChecks appends the given checks to the attribute list.

func (*Table) AddColumns 

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

AddColumns appends the given columns to the table column list.

func (*Table) AddDeps 

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

AddDeps adds the given objects as dependencies to the view.

func (*Table) AddForeignKeys 

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

AddForeignKeys appends the given foreign-keys to the table foreign-key list.

func (*Table) AddIndexes 

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

AddIndexes appends the given indexes to the table index list.

func (*Table) Column 

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

Column returns the first column that matched the given name.

func (*Table) ForeignKey 

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

ForeignKey returns the first foreign-key that matched the given symbol (constraint name).

func (*Table) Index 

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

Index returns the first index that matched the given name.

func (*Table) SetCharset 

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

SetCharset sets or appends the Charset attribute to the table with the given value.

func (*Table) SetCollation 

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

SetCollation sets or appends the Collation attribute to the table with the given value.

func (*Table) SetComment 

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

SetComment sets or appends the Comment attribute to the table with the given value.

func (*Table) SetPrimaryKey 

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

SetPrimaryKey sets the primary-key of the table.

func (*Table) SetSchema 

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

SetSchema sets the schema (named-database) of the table.

func (*Table) Trigger 

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

Trigger returns the first trigger that matches the given name.

func (*Table) UnsetCharset 

func (t *Table) UnsetCharset() *Table

UnsetCharset unsets the Charset attribute.

func (*Table) UnsetCollation 

func (t *Table) UnsetCollation() *Table

UnsetCollation the Collation attribute.

type TimeOption 

type TimeOption func(*TimeType)

TimeOption allows configuring TimeType using functional options.

func TimePrecision 

func TimePrecision(precision int) TimeOption

TimePrecision configures the precision of the time type.

func TimeScale 

func TimeScale(scale int) TimeOption

TimeScale configures the scale of the time type.

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 

func TriggerEventUpdateOf(columns ...*Column) TriggerEvent

TriggerEventUpdateOf returns an UPDATE OF trigger event.

type TriggerFor 

type TriggerFor string

TriggerFor represents the trigger FOR EACH spec. 

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

List of supported trigger FOR EACH spec.

type TriggerTime 

type TriggerTime string

TriggerTime represents the trigger action time. 

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

List of supported trigger action times.

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 

func UnderlyingType(t Type) Type

UnderlyingType returns the underlying type of t.

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 

func NewMaterializedView(name, def string) *View

NewMaterializedView creates a new materialized View.

func NewView 

func NewView(name, def string) *View

NewView creates a new View.

func (*View) AddAttrs 

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

AddAttrs adds and additional attributes to the view.

func (*View) AddColumns 

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

AddColumns appends the given columns to the table column list.

func (*View) AddDeps 

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

AddDeps adds the given objects as dependencies to the view.

func (*View) AddIndexes 

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

AddIndexes appends the given indexes to the table index list.

func (*View) AsTable 

func (v *View) AsTable() *Table

AsTable returns a table that represents the view.

func (*View) Column 

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

Column returns the first column that matched the given name.

func (*View) Index 

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

Index returns the first index that matched the given name.

func (*View) Materialized 

func (v *View) Materialized() bool

Materialized reports if the view is materialized.

func (*View) SetCheckOption 

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

SetCheckOption sets the check option of the view.

func (*View) SetComment 

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

SetComment sets or appends the Comment attribute to the view with the given value.

func (*View) SetMaterialized 

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

SetMaterialized reports if the view is materialized.

func (*View) SetSchema 

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

SetSchema sets the schema (named-database) of the view.

func (*View) Trigger 

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

Trigger returns the first trigger that matches the given name.

type ViewCheckOption 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.