migration

type AddConstraint ¶

type AddConstraint struct {
	Table      string
	Constraint Constraint
}

AddConstraint adds a unique or check constraint to a table.

type AddField ¶

type AddField struct {
	Table, Name string
	Field       Field
}

AddField adds a column to a table.

type AddIndex ¶

type AddIndex struct {
	Table string
	Index Index
}

AddIndex makes a declared index.

type AlterField ¶

type AlterField struct {
	Table, Name string
	Field       Field
}

AlterField changes a column's definition: its type, nullability, default, key, foreign key, generated expression.

type AlterModelTable ¶

type AlterModelTable = RenameModel

AlterModelTable is RenameModel, by Django's name for changing a model's table: here a model is its table.

type Constraint ¶

type Constraint = schema.Constraint

Constraint is a table's unique constraint (Unique) or check constraint (Check).

func Check(name, expr string) Constraint

func Unique(name string, columns ...string) Constraint

type CreateExtension ¶

type CreateExtension struct{ Name string }

CreateExtension installs a Postgres extension ("vector", "pg_trgm"); other databases have none, and it does nothing there.

type CreateFunction ¶

type CreateFunction struct {
	Name            string
	Params, Returns Dialects
	Body            Dialects
	Language        string
	Volatile        bool // the result may differ for the same arguments: not IMMUTABLE / DETERMINISTIC
}

CreateFunction creates a function written in SQL on Postgres and MySQL, for an orm.Func to call; unapplying it drops it. SQLite runs no functions written in SQL — register a Go one with orm/sqlite's Func — and a dialect whose Body is empty gets nothing. Params and Returns are spelt as each database spells them; Body is Postgres's function body in Language (sql when empty: a SELECT or an expression's RETURN) and MySQL's routine body (RETURN …, or BEGIN … END, run whole).

m.CreateFunction{
	Name:    "initials",
	Params:  m.Dialects{Postgres: "s text", MySQL: "s VARCHAR(255)"},
	Returns: m.Dialects{Postgres: "text", MySQL: "VARCHAR(255)"},
	Body:    m.Dialects{Postgres: "SELECT upper(left(s, 1))", MySQL: "RETURN UPPER(LEFT(s, 1))"},
}

type CreateModel ¶

type CreateModel struct {
	Table       string
	Fields      []NamedField
	Constraints []Constraint
	Indexes     []Index
}

CreateModel creates a table.

type DeleteModel ¶

type DeleteModel struct{ Table string }

DeleteModel drops a table.

type Dialects ¶

type Dialects = schema.Dialects

Dialects is SQL written for each dialect: "" where a dialect has none.

type Field ¶

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

Field is a column's definition: a kind (BigAuto, Varchar, Time, …) and what its methods add.

func Auto() Field

func BigAuto() Field

func BigInt() Field

func Bool() Field

func Bytes() Field

func Custom() Field

func Date() Field

func Float() Field

func Float32() Field

func Int() Field

func JSON() Field

func SmallInt() Field

func TSVector() Field

func Text() Field

func Time() Field

func UUID() Field

func Varchar(size int) Field

func Vector(dims int) Field

func (f Field) Auto() Field

func (f Field) Collation(name string) Field

func (f Field) Comment(s string) Field

func (f Field) Default(v any) Field

func (f Field) DefaultSQL(expr string) Field

func (f Field) FK(table, ref string) Field

func (f Field) Generated(expr Dialects) Field

func (f Field) Index() Field

func (f Field) Null() Field

func (f Field) OnDelete(action string) Field

func (f Field) PK() Field

func (f Field) Precision(n int) Field

func (f Field) Type(sql string) Field

func (f Field) Types(t Dialects) Field

func (f Field) Unique() Field

func (f Field) Unsigned() Field

type Index ¶

type Index = schema.Index

Index is an index a model declares (GIN, HNSW, IVFFlat, FULLTEXT, a SearchVector's), as the statement making it on each dialect: none where it has no SQL (SQLite makes none of them).

type Migration ¶

type Migration struct {
	Name string // NNNN_words, unique within its database
	DB   string // the database's name (orm.AddDatabase); "" the default
	// Dependencies is the migrations applied before it: names of its
	// database's, or "<db>:<name>" of another's (":<name>" the default's).
	Dependencies []string
	Operations   []Operation
}

Migration is one step of a database's schema: its operations, applied in order, after the migrations it depends on.

func Find(ordered []Migration, db, name string) (Migration, error)

func Of(ordered []Migration, db string) []Migration

func Order(list []Migration) ([]Migration, error)

func Ordered() ([]Migration, error)

func (mg Migration) Apply(s *State) error

func (mg Migration) Backwards(dialect string, s *State) ([]Step, error)

func (mg Migration) Forwards(dialect string, s *State) ([]Step, error)

type NamedField ¶

type NamedField struct {
	Name  string
	Field Field
}

NamedField is a column of CreateModel: its name and Field.

func F(name string, f Field) NamedField

type Operation ¶

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

Operation is a change of the schema: what it does to the state, and the SQL doing it, forwards and back.

func Diff(from, to *State, ask func(question string) bool) ([]Operation, []string)

type RemoveConstraint ¶

type RemoveConstraint struct{ Table, Name string }

RemoveConstraint drops a unique or check constraint of a table.

type RemoveField ¶

type RemoveField struct{ Table, Name string }

RemoveField drops a column of a table, and its data.

type RemoveIndex ¶

type RemoveIndex struct{ Table, Name string }

RemoveIndex drops a declared index.

type RenameField ¶

type RenameField struct{ Table, Old, New string }

RenameField renames a column, its data kept.

type RenameModel ¶

type RenameModel struct{ Old, New string }

RenameModel renames a table, its rows kept: the constraints and indexes keep their names, the foreign keys referring to it follow.

type RunGo ¶

type RunGo struct {
	Forward, Backward func(ctx context.Context, tx Tx) error
}

RunGo runs Go code, a data migration, in the migration's transaction: tx runs SQL in it, and the ORM's queries on ctx do too. Backward undoes it; nil, the migration can't be unapplied. It sees the database as the operations before it leave it, so query it in SQL, or with models that match that schema.

type RunSQL ¶

type RunSQL struct {
	SQL, ReverseSQL string
	Dialect         string
}

RunSQL runs SQL of your own (statements ending with semicolons), on every dialect or on Dialect's alone. ReverseSQL undoes it: empty, the migration can't be unapplied; Noop, there is nothing to undo.

type State ¶

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

State is a database's schema as its migrations leave it: its tables and extensions.

func NewState(tables []schema.Table, exts []string) *State

func Replay(ordered []Migration, db string) (*State, error)

func (s *State) Clone() *State

func (s *State) Tables() []schema.Table

type Step ¶

type Step struct {
	SQL string
	Go  func(ctx context.Context, tx Tx) error
}

Step is a statement (or several, a RunSQL's) applying an operation, or Go code a RunGo runs. A step with both runs its Go, and shows its SQL.

type Tx ¶

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

Tx is where a RunGo runs: the migration's transaction (MySQL, which can't roll DDL back, its connection).