Documentation

Overview

    Package schema contains all schema migration logic for SQL dialects.

    Index

    Constants

    View Source
    const (
    	// TypeTable defines the table name holding the type information.
    	TypeTable = "ent_types"
    	// MaxTypes defines the max number of types can be created when
    	// defining universal ids. The left 16-bits are reserved.
    	MaxTypes = math.MaxUint16
    )
    View Source
    const (
    	// DefaultStringLen describes the default length for string/varchar types.
    	DefaultStringLen int64 = 255
    	// Null is the string representation of NULL in SQL.
    	Null = "NULL"
    	// PrimaryKey is the string representation of PKs in SQL.
    	PrimaryKey = "PRI"
    	// UniqueKey is the string representation of PKs in SQL.
    	UniqueKey = "UNI"
    )

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Column

    type Column struct {
    	Name       string            // column name.
    	Type       field.Type        // column type.
    	SchemaType map[string]string // optional schema type per dialect.
    	Attr       string            // extra attributes.
    	Size       int64             // max size parameter for string, blob, etc.
    	Key        string            // key definition (PRI, UNI or MUL).
    	Unique     bool              // column with unique constraint.
    	Increment  bool              // auto increment attribute.
    	Nullable   bool              // null or not null attribute.
    	Default    interface{}       // default value.
    	Enums      []string          // enum values.
    	// contains filtered or unexported fields
    }

      Column schema definition for SQL dialects.

      func (*Column) ConvertibleTo

      func (c *Column) ConvertibleTo(d *Column) bool

        ConvertibleTo reports whether a column can be converted to the new column without altering its data.

        func (Column) FloatType

        func (c Column) FloatType() bool

          FloatType reports of the given type is a float type (float32, float64).

          func (Column) IntType

          func (c Column) IntType() bool

            IntType reports whether the column is an int type (int8 ... int64).

            func (*Column) PrimaryKey

            func (c *Column) PrimaryKey() bool

              PrimaryKey returns boolean indicates if this column is on of the primary key columns. Used by the migration tool when parsing the `DESCRIBE TABLE` output Go objects.

              func (*Column) ScanDefault

              func (c *Column) ScanDefault(value string) error

                ScanDefault scans the default value string to its interface type.

                func (Column) UintType

                func (c Column) UintType() bool

                  UintType reports of the given type is a uint type (int8 ... int64).

                  func (*Column) UniqueKey

                  func (c *Column) UniqueKey() bool

                    UniqueKey returns boolean indicates if this column is a unique key. Used by the migration tool when parsing the `DESCRIBE TABLE` output Go objects.

                    type CreateFunc

                    type CreateFunc func(context.Context, ...*Table) error

                      The CreateFunc type is an adapter to allow the use of ordinary function as Creator. If f is a function with the appropriate signature, CreateFunc(f) is a Creator that calls f.

                      func (CreateFunc) Create

                      func (f CreateFunc) Create(ctx context.Context, tables ...*Table) error

                        Create calls f(ctx, tables...).

                        type Creator

                        type Creator interface {
                        	// Create creates the given tables in the database. See Migrate.Create for more details.
                        	Create(context.Context, ...*Table) error
                        }

                          Creator is the interface that wraps the Create method.

                          type ForeignKey

                          type ForeignKey struct {
                          	Symbol     string          // foreign-key name. Generated if empty.
                          	Columns    []*Column       // table column
                          	RefTable   *Table          // referenced table.
                          	RefColumns []*Column       // referenced columns.
                          	OnUpdate   ReferenceOption // action on update.
                          	OnDelete   ReferenceOption // action on delete.
                          }

                            ForeignKey definition for creation.

                            func (ForeignKey) DSL

                            func (fk ForeignKey) DSL() *sql.ForeignKeyBuilder

                              DSL returns a default DSL query for a foreign-key.

                              type Hook

                              type Hook func(Creator) Creator

                                Hook defines the "create middleware". A function that gets a Creator and returns a Creator. For example:

                                hook := func(next schema.Creator) schema.Creator {
                                	return schema.CreateFunc(func(ctx context.Context, tables ...*schema.Table) error {
                                		fmt.Println("Tables:", tables)
                                		return next.Create(ctx, tables...)
                                	})
                                }
                                

                                type Index

                                type Index struct {
                                	Name    string    // index name.
                                	Unique  bool      // uniqueness.
                                	Columns []*Column // actual table columns.
                                	// contains filtered or unexported fields
                                }

                                  Index definition for table index.

                                  func (*Index) Builder

                                  func (i *Index) Builder(table string) *sql.IndexBuilder

                                    Builder returns the query builder for index creation. The DSL is identical in all dialects.

                                    func (*Index) DropBuilder

                                    func (i *Index) DropBuilder(table string) *sql.DropIndexBuilder

                                      DropBuilder returns the query builder for the drop index.

                                      type Indexes

                                      type Indexes []*Index

                                        Indexes used for scanning all sql.Rows into a list of indexes, because multiple sql rows can represent the same index (multi-columns indexes).

                                        type InspectOption

                                        type InspectOption func(inspect *Inspector)

                                          MigrateOption allows for managing schema configuration using functional options.

                                          func WithSchema

                                          func WithSchema(schema string) InspectOption

                                            WithSchema provides a schema (named-database) for reading the tables from.

                                            type Inspector

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

                                              An Inspector provides methods for inspecting database tables.

                                              func NewInspect

                                              func NewInspect(d dialect.Driver, opts ...InspectOption) (*Inspector, error)

                                                NewInspect returns an inspector for the given SQL driver.

                                                func (*Inspector) Tables

                                                func (i *Inspector) Tables(ctx context.Context) ([]*Table, error)

                                                  Tables returns the tables in the schema.

                                                  type Migrate

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

                                                    Migrate runs the migrations logic for the SQL dialects.

                                                    func NewMigrate

                                                    func NewMigrate(d dialect.Driver, opts ...MigrateOption) (*Migrate, error)

                                                      NewMigrate create a migration structure for the given SQL driver.

                                                      func (*Migrate) Create

                                                      func (m *Migrate) Create(ctx context.Context, tables ...*Table) error

                                                        Create creates all schema resources in the database. It works in an "append-only" mode, which means, it only create tables, append column to tables or modifying column type.

                                                        Column can be modified by turning into a NULL from NOT NULL, or having a type conversion not resulting data altering. From example, changing varchar(255) to varchar(120) is invalid, but changing varchar(120) to varchar(255) is valid. For more info, see the convert function below.

                                                        Note that SQLite dialect does not support (this moment) the "append-only" mode describe above, since it's used only for testing.

                                                        type MigrateOption

                                                        type MigrateOption func(*Migrate)

                                                          MigrateOption allows for managing schema configuration using functional options.

                                                          func WithDropColumn

                                                          func WithDropColumn(b bool) MigrateOption

                                                            WithDropColumn sets the columns dropping option to the migration. Defaults to false.

                                                            func WithDropIndex

                                                            func WithDropIndex(b bool) MigrateOption

                                                              WithDropIndex sets the indexes dropping option to the migration. Defaults to false.

                                                              func WithFixture

                                                              func WithFixture(b bool) MigrateOption

                                                                WithFixture sets the foreign-key renaming option to the migration when upgrading ent from v0.1.0 (issue-#285). Defaults to false.

                                                                func WithForeignKeys

                                                                func WithForeignKeys(b bool) MigrateOption

                                                                  WithForeignKeys enables creating foreign-key in ddl. Defaults to true.

                                                                  func WithGlobalUniqueID

                                                                  func WithGlobalUniqueID(b bool) MigrateOption

                                                                    WithGlobalUniqueID sets the universal ids options to the migration. Defaults to false.

                                                                    func WithHooks

                                                                    func WithHooks(hooks ...Hook) MigrateOption

                                                                      WithHooks adds a list of hooks to the schema migration.

                                                                      type MySQL

                                                                      type MySQL struct {
                                                                      	dialect.Driver
                                                                      	// contains filtered or unexported fields
                                                                      }

                                                                        MySQL is a MySQL migration driver.

                                                                        type Postgres

                                                                        type Postgres struct {
                                                                        	dialect.Driver
                                                                        	// contains filtered or unexported fields
                                                                        }

                                                                          Postgres is a postgres migration driver.

                                                                          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.

                                                                              func (ReferenceOption) ConstName

                                                                              func (r ReferenceOption) ConstName() string

                                                                                ConstName returns the constant name of a reference option. It's used by entc for printing the constant name in templates.

                                                                                type SQLite

                                                                                type SQLite struct {
                                                                                	dialect.Driver
                                                                                	WithForeignKeys bool
                                                                                }

                                                                                  SQLite is an SQLite migration driver.

                                                                                  type Table

                                                                                  type Table struct {
                                                                                  	Name    string
                                                                                  	Columns []*Column
                                                                                  
                                                                                  	Indexes     []*Index
                                                                                  	PrimaryKey  []*Column
                                                                                  	ForeignKeys []*ForeignKey
                                                                                  	Annotation  *entsql.Annotation
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                    Table schema definition for SQL dialects.

                                                                                    func NewTable

                                                                                    func NewTable(name string) *Table

                                                                                      NewTable returns a new table with the given name.

                                                                                      func (*Table) AddColumn

                                                                                      func (t *Table) AddColumn(c *Column) *Table

                                                                                        AddColumn adds a new column to the table.

                                                                                        func (*Table) AddForeignKey

                                                                                        func (t *Table) AddForeignKey(fk *ForeignKey) *Table

                                                                                          AddForeignKey adds a foreign key to the table.

                                                                                          func (*Table) AddIndex

                                                                                          func (t *Table) AddIndex(name string, unique bool, columns []string) *Table

                                                                                            AddIndex creates and adds a new index to the table from the given options.

                                                                                            func (*Table) AddPrimary

                                                                                            func (t *Table) AddPrimary(c *Column) *Table

                                                                                              AddPrimary adds a new primary key to the table.

                                                                                              func (*Table) HasColumn

                                                                                              func (t *Table) HasColumn(name string) bool

                                                                                                HasColumn reports if the table contains a column with the given name.

                                                                                                func (*Table) SetAnnotation

                                                                                                func (t *Table) SetAnnotation(ant *entsql.Annotation) *Table

                                                                                                  SetAnnotation the entsql.Annotation on the table.

                                                                                                  type WriteDriver

                                                                                                  type WriteDriver struct {
                                                                                                  	dialect.Driver // underlying driver.
                                                                                                  	io.Writer      // target for exec statements.
                                                                                                  }

                                                                                                    WriteDriver is a driver that writes all driver exec operations to its writer.

                                                                                                    func (*WriteDriver) Commit

                                                                                                    func (w *WriteDriver) Commit() error

                                                                                                      Commit writes the transaction commit.

                                                                                                      func (*WriteDriver) Exec

                                                                                                      func (w *WriteDriver) Exec(_ context.Context, query string, _, _ interface{}) error

                                                                                                        Exec writes its query and calls the underlying driver Exec method.

                                                                                                        func (*WriteDriver) Rollback

                                                                                                        func (w *WriteDriver) Rollback() error

                                                                                                          Rollback writes the transaction rollback.

                                                                                                          func (*WriteDriver) Tx

                                                                                                            Tx writes the transaction start.