fluent_sql

Documentation

Index

• type Annotation
  • func Check(c string) *Annotation
  • func Checks(c map[string]string) *Annotation
  • func Default(literal string) *Annotation
  • func DefaultExpr(expr string) *Annotation
  • func DefaultExprs(exprs map[string]string) *Annotation
  • func OnDelete(opt ReferenceOption) *Annotation
  • func Schema(s string) *Annotation
  • func SchemaTable(s, t string) *Annotation
  • func Skip() *Annotation
  • func Table(t string) *Annotation
  • func View(as string) *Annotation
  • func ViewFor(dialect string, as func(*sql.Selector)) *Annotation
  • func WithComments(b bool) *Annotation
  • func (a Annotation) Err() error
  • func (a Annotation) Merge(other schema.Annotation) schema.Annotation
  • func (Annotation) Name() string
• type IndexAnnotation
  • func Desc() *IndexAnnotation
  • func DescColumns(names ...string) *IndexAnnotation
  • func IncludeColumns(names ...string) *IndexAnnotation
  • func IndexType(t string) *IndexAnnotation
  • func IndexTypes(types map[string]string) *IndexAnnotation
  • func IndexWhere(pred string) *IndexAnnotation
  • func OpClass(op string) *IndexAnnotation
  • func OpClassColumn(name, op string) *IndexAnnotation
  • func Prefix(prefix uint) *IndexAnnotation
  • func PrefixColumn(name string, prefix uint) *IndexAnnotation
  • func (a IndexAnnotation) Merge(other schema.Annotation) schema.Annotation
  • func (IndexAnnotation) Name() string
• type ReferenceOption

Types

type Annotation

type Annotation struct {
	// The Schema option allows setting the schema which the table belongs to.
	// Note, this option is no-op for Ent default migration engine. However, schema
	// extensions (like Atlas) can accept this option and implement it accordingly.
	//
	//	fluent_sql.Annotation{
	//		Schema: "public",
	//	}
	//
	Schema string `json:"schema,omitempty"`

	// The Table option allows overriding the default table
	// name that is generated by fluent. For example:
	//
	//	fluent_sql.Annotation{
	//		Table: "Users",
	//	}
	//
	Table string `json:"table,omitempty"`

	// Charset defines the character-set of the table. For example:
	//
	//	fluent_sql.Annotation{
	//		Charset: "utf8mb4",
	//	}
	//
	Charset string `json:"charset,omitempty"`

	// Collation defines the collation of the table (a set of rules for comparing
	// characters in a character set). For example:
	//
	//	fluent_sql.Annotation{
	//		Collation: "utf8mb4_bin",
	//	}
	//
	Collation string `json:"collation,omitempty"`

	// Default specifies a literal default value of a column. Note that using
	// this option overrides the default behavior of the code-generation.
	//
	//	fluent_sql.Annotation{
	//		Default: `{"key":"value"}`,
	//	}
	//
	Default string `json:"default,omitempty"`

	// DefaultExpr specifies an expression default value of a column. Using this option,
	// users can define custom expressions to be set as database default values. Note that
	// using this option overrides the default behavior of the code-generation.
	//
	//	fluent_sql.Annotation{
	//		DefaultExpr: "CURRENT_TIMESTAMP",
	//	}
	//
	//	fluent_sql.Annotation{
	//		DefaultExpr: "uuid_generate_v4()",
	//	}
	//
	//	fluent_sql.Annotation{
	//		DefaultExpr: "(a + b)",
	//	}
	//
	DefaultExpr string `json:"default_expr,omitempty"`

	// DefaultExpr specifies an expression default value of a column per dialect.
	// See, DefaultExpr for full doc.
	//
	//	fluent_sql.Annotation{
	//		DefaultExprs: map[string]string{
	//			dialect.MySQL:    "uuid()",
	//			dialect.Postgres: "uuid_generate_v4",
	//		}
	//
	DefaultExprs map[string]string `json:"default_exprs,omitempty"`

	// Options defines the additional table options. For example:
	//
	//	fluent_sql.Annotation{
	//		Options: "ENGINE = INNODB",
	//	}
	//
	Options string `json:"options,omitempty"`

	// Size defines the column size in the generated schema. For example:
	//
	//	fluent_sql.Annotation{
	//		Size: 128,
	//	}
	//
	Size int64 `json:"size,omitempty"`

	// WithComments specifies whether fields' comments should
	// be stored in the database schema as column comments.
	//
	//  withCommentsEnabled := true
	//	fluent_sql.WithComments{
	//		WithComments: &withCommentsEnabled,
	//	}
	//
	WithComments *bool `json:"with_comments,omitempty"`

	// Incremental defines the auto-incremental behavior of a column. For example:
	//
	//  incrementalEnabled := true
	//  fluent_sql.Annotation{
	//      Incremental: &incrementalEnabled,
	//  }
	//
	// By default, this value is nil defaulting to whatever best fits each scenario.
	//
	Incremental *bool `json:"incremental,omitempty"`

	// OnDelete specifies a custom referential action for DELETE operations on parent
	// table that has matching rows in the child table.
	//
	// For example, in order to delete rows from the parent table and automatically delete
	// their matching rows in the child table, pass the following annotation:
	//
	//	fluent_sql.Annotation{
	//		OnDelete: fluent_sql.Cascade,
	//	}
	//
	OnDelete ReferenceOption `json:"on_delete,omitempty"`

	// Check allows injecting custom "DDL" for setting an unnamed "CHECK" clause in "CREATE TABLE".
	//
	//	fluent_sql.Annotation{
	//		Check: "age < 10",
	//	}
	//
	Check string `json:"check,omitempty"`

	// Checks allows injecting custom "DDL" for setting named "CHECK" clauses in "CREATE TABLE".
	//
	//	fluent_sql.Annotation{
	//		Checks: map[string]string{
	//			"valid_discount": "price > discount_price",
	//		},
	//	}
	//
	Checks map[string]string `json:"checks,omitempty"`

	// Skip indicates that the field or the schema is skipped/ignored during
	// migration (e.g., defined externally).
	//
	//	fluent_sql.Annotation{
	//		Skip: true,
	//	}
	//
	Skip bool `json:"skip,omitempty"`

	// ViewAs allows defining a view for the schema. For example:
	//
	//	fluent_sql.Annotation{
	//		View: "SELECT name FROM users",
	//	}
	ViewAs string `json:"view_as,omitempty"`

	// ViewFor allows defining a view for the schema per dialect. For example:
	//
	//	fluent_sql.Annotation{
	//		ViewFor: map[string]string{
	//			dialect.MySQL:    "...",
	//			dialect.Postgres: "...",
	//		},
	//	}
	ViewFor map[string]string `json:"view_for,omitempty"`
	// contains filtered or unexported fields
}

Annotation is a builtin schema annotation for attaching SQL metadata to schema objects for both codegen and runtime.

func Check

func Check(c string) *Annotation

Check allows injecting custom "DDL" for setting an unnamed "CHECK" clause in "CREATE TABLE".

fluent_sql.Annotation{
	Check: "(`age` < 10)",
}

func Checks

func Checks(c map[string]string) *Annotation

Checks allows injecting custom "DDL" for setting named "CHECK" clauses in "CREATE TABLE".

fluent_sql.Annotation{
	Checks: map[string]string{
		"valid_discount": "price > discount_price",
	},
}

func Default

func Default(literal string) *Annotation

Default specifies a literal default value of a column. Note that using this option overrides the default behavior of the code-generation.

fluent_sql.Annotation{
	Default: `{"key":"value"}`,
}

func DefaultExpr

func DefaultExpr(expr string) *Annotation

DefaultExpr specifies an expression default value for the annotated column. Using this option, users can define custom expressions to be set as database default values.Note that using this option overrides the default behavior of the code-generation.

field.UUID("id", uuid.Nil).
	Default(uuid.New).
	Annotations(
		fluent_sql.DefaultExpr("uuid_generate_v4()"),
	)

func DefaultExprs

func DefaultExprs(exprs map[string]string) *Annotation

DefaultExprs specifies an expression default value for the annotated column per dialect. See, DefaultExpr for full doc.

field.UUID("id", uuid.Nil).
	Default(uuid.New).
	Annotations(
		fluent_sql.DefaultExprs(map[string]string{
			dialect.MySQL:    "uuid()",
			dialect.Postgres: "uuid_generate_v4()",
		}),
	)

func OnDelete

func OnDelete(opt ReferenceOption) *Annotation

OnDelete specifies a custom referential action for DELETE operations on parent table that has matching rows in the child table.

For example, in order to delete rows from the parent table and automatically delete their matching rows in the child table, pass the following annotation:

func (T) Annotations() []schema.Annotation {
	return []schema.Annotation{
		fluent_sql.OnDelete(fluent_sql.Cascade),
	}
}

func Schema

func Schema(s string) *Annotation

The Schema option allows setting the schema which the table belongs to. Note, this option is no-op for Ent default migration engine. However, schema extensions (like Atlas) can accept this option and implement it accordingly.

func (T) Annotations() []schema.Annotation {
	return []schema.Annotation{
		fluent_sql.Schema("public"),
	}
}

func SchemaTable

func SchemaTable(s, t string) *Annotation

SchemaTable allows setting both schema and table name in one annotation.

func Skip

func Skip() *Annotation

Skip indicates that the field or the schema is skipped/ignored during migration (e.g., defined externally).

func Table

func Table(t string) *Annotation

The Table option allows overriding the default table name that is generated by fluent. For example:

func (T) Annotations() []schema.Annotation {
	return []schema.Annotation{
		fluent_sql.Table("Users"),
	}
}

func View

func View(as string) *Annotation

View specifies the definition of a view.

func ViewFor

func ViewFor(dialect string, as func(*sql.Selector)) *Annotation

ViewFor specifies the definition of a view.

func WithComments

func WithComments(b bool) *Annotation

WithComments specifies whether fields' comments should be stored in the database schema as column comments.

func (T) Annotations() []schema.Annotation {
	return []schema.Annotation{
		fluent_sql.WithComments(true),
	}
}

func (Annotation) Err

func (a Annotation) Err() error

Err returns the error that occurred during annotation build, if any.

func (Annotation) Merge

func (a Annotation) Merge(other schema.Annotation) schema.Annotation

Merge implements the schema.Merger interface.

func (Annotation) Name

func (Annotation) Name() string

Name describes the annotation name.

type IndexAnnotation

type IndexAnnotation struct {
	// Prefix defines a column prefix for a single string column index.
	// In MySQL, the following annotation maps to:
	//
	//	index.Fields("column").
	//		Annotation(fluent_sql.Prefix(100))
	//
	//	CREATE INDEX `table_column` ON `table`(`column`(100))
	//
	Prefix uint

	// PrefixColumns defines column prefixes for a multi-column index.
	// In MySQL, the following annotation maps to:
	//
	//	index.Fields("c1", "c2", "c3").
	//		Annotation(
	//			fluent_sql.PrefixColumn("c1", 100),
	//			fluent_sql.PrefixColumn("c2", 200),
	//		)
	//
	//	CREATE INDEX `table_c1_c2_c3` ON `table`(`c1`(100), `c2`(200), `c3`)
	//
	PrefixColumns map[string]uint

	// Desc defines the DESC clause for a single column index.
	// In MySQL, the following annotation maps to:
	//
	//	index.Fields("column").
	//		Annotation(fluent_sql.Desc())
	//
	//	CREATE INDEX `table_column` ON `table`(`column` DESC)
	//
	Desc bool

	// DescColumns defines the DESC clause for columns in multi-column index.
	// In MySQL, the following annotation maps to:
	//
	//	index.Fields("c1", "c2", "c3").
	//		Annotation(
	//			fluent_sql.DescColumns("c1", "c2"),
	//		)
	//
	//	CREATE INDEX `table_c1_c2_c3` ON `table`(`c1` DESC, `c2` DESC, `c3`)
	//
	DescColumns map[string]bool

	// IncludeColumns defines the INCLUDE clause for the index.
	// Works only in Postgres and its definition is as follows:
	//
	//	index.Fields("c1").
	//		Annotation(
	//			fluent_sql.IncludeColumns("c2"),
	//		)
	//
	//	CREATE INDEX "table_column" ON "table"("c1") INCLUDE ("c2")
	//
	IncludeColumns []string

	// Type defines the type of the index.
	// In MySQL, the following annotation maps to:
	//
	//	index.Fields("c1").
	//		Annotation(
	//			fluent_sql.IndexType("FULLTEXT"),
	//		)
	//
	//	CREATE FULLTEXT INDEX `table_c1` ON `table`(`c1`)
	//
	Type string

	// Types is like the Type option but allows mapping an index-type per dialect.
	//
	//	index.Fields("c1").
	//		Annotation(
	//			fluent_sql.IndexTypes(map[string]string{
	//				dialect.MySQL:		"FULLTEXT",
	//				dialect.Postgres:	"GIN",
	//			}),
	//		)
	//
	Types map[string]string

	// OpClass defines the operator class for a single string column index.
	// In PostgreSQL, the following annotation maps to:
	//
	//	index.Fields("column").
	//		Annotation(
	//			fluent_sql.IndexType("BRIN"),
	//			fluent_sql.OpClass("int8_bloom_ops"),
	//		)
	//
	//	CREATE INDEX "table_column" ON "table" USING BRIN ("column" int8_bloom_ops)
	//
	OpClass string

	// OpClassColumns defines operator-classes for a multi-column index.
	// In PostgreSQL, the following annotation maps to:
	//
	//	index.Fields("c1", "c2", "c3").
	//		Annotation(
	//			fluent_sql.IndexType("BRIN"),
	//			fluent_sql.OpClassColumn("c1", "int8_bloom_ops"),
	//			fluent_sql.OpClassColumn("c2", "int8_minmax_multi_ops(values_per_range=8)"),
	//		)
	//
	//	CREATE INDEX "table_column" ON "table" USING BRIN ("c1" int8_bloom_ops, "c2" int8_minmax_multi_ops(values_per_range=8), "c3")
	//
	OpClassColumns map[string]string

	// IndexWhere allows configuring partial indexes in SQLite and PostgreSQL.
	// Read more: https://postgresql.org/docs/current/indexes-partial.html.
	//
	// Note that the `WHERE` clause should be defined exactly like it is
	// stored in the database (i.e. normal form). Read more about this on
	// the Atlas website: https://atlasgo.io/concepts/dev-database#diffing.
	//
	//	index.Fields("a").
	//		Annotations(
	//			fluent_sql.IndexWhere("b AND c > 0"),
	//		)
	//	CREATE INDEX "table_a" ON "table"("a") WHERE (b AND c > 0)
	Where string
}

IndexAnnotation is a builtin schema annotation for attaching SQL metadata to schema indexes for both codegen and runtime.

func Desc

func Desc() *IndexAnnotation

Desc returns a new index annotation with the DESC clause for a single column index. In MySQL, the following annotation maps to:

index.Fields("column").
	Annotation(fluent_sql.Desc())

CREATE INDEX `table_column` ON `table`(`column` DESC)

func DescColumns

func DescColumns(names ...string) *IndexAnnotation

DescColumns returns a new index annotation with the DESC clause attached to the columns in the index. In MySQL, the following annotation maps to:

index.Fields("c1", "c2", "c3").
	Annotation(
		fluent_sql.DescColumns("c1", "c2"),
	)

CREATE INDEX `table_c1_c2_c3` ON `table`(`c1` DESC, `c2` DESC, `c3`)

func IncludeColumns

func IncludeColumns(names ...string) *IndexAnnotation

IncludeColumns defines the INCLUDE clause for the index. Works only in Postgres and its definition is as follows:

index.Fields("c1").
	Annotation(
		fluent_sql.IncludeColumns("c2"),
	)

CREATE INDEX "table_column" ON "table"("c1") INCLUDE ("c2")

func IndexType

func IndexType(t string) *IndexAnnotation

IndexType defines the type of the index. In MySQL, the following annotation maps to:

index.Fields("c1").
	Annotation(
		fluent_sql.IndexType("FULLTEXT"),
	)

CREATE FULLTEXT INDEX `table_c1` ON `table`(`c1`)

func IndexTypes

func IndexTypes(types map[string]string) *IndexAnnotation

IndexTypes is like the Type option but allows mapping an index-type per dialect.

index.Fields("c1").
	Annotations(
		fluent_sql.IndexTypes(map[string]string{
			dialect.MySQL:    "FULLTEXT",
			dialect.Postgres: "GIN",
		}),
	)

func IndexWhere

func IndexWhere(pred string) *IndexAnnotation

IndexWhere allows configuring partial indexes in SQLite and PostgreSQL. Read more: https://postgresql.org/docs/current/indexes-partial.html.

Note that the `WHERE` clause should be defined exactly like it is stored in the database (i.e. normal form). Read more about this on the Atlas website: https://atlasgo.io/concepts/dev-database#diffing.

index.Fields("a").
	Annotations(
		fluent_sql.IndexWhere("b AND c > 0"),
	)
CREATE INDEX "table_a" ON "table"("a") WHERE (b AND c > 0)

func OpClass

func OpClass(op string) *IndexAnnotation

OpClass defines the operator class for a single string column index. In PostgreSQL, the following annotation maps to:

index.Fields("column").
	Annotation(
		fluent_sql.IndexType("BRIN"),
		fluent_sql.OpClass("int8_bloom_ops"),
	)

CREATE INDEX "table_column" ON "table" USING BRIN ("column" int8_bloom_ops)

func OpClassColumn

func OpClassColumn(name, op string) *IndexAnnotation

OpClassColumn returns a new index annotation with column operator class for multi-column indexes. In PostgreSQL, the following annotation maps to:

index.Fields("c1", "c2", "c3").
	Annotation(
		fluent_sql.IndexType("BRIN"),
		fluent_sql.OpClassColumn("c1", "int8_bloom_ops"),
		fluent_sql.OpClassColumn("c2", "int8_minmax_multi_ops(values_per_range=8)"),
	)

CREATE INDEX "table_column" ON "table" USING BRIN ("c1" int8_bloom_ops, "c2" int8_minmax_multi_ops(values_per_range=8), "c3")

func Prefix

func Prefix(prefix uint) *IndexAnnotation

Prefix returns a new index annotation with a single string column index. In MySQL, the following annotation maps to:

index.Fields("column").
	Annotation(fluent_sql.Prefix(100))

CREATE INDEX `table_column` ON `table`(`column`(100))

func PrefixColumn

func PrefixColumn(name string, prefix uint) *IndexAnnotation

PrefixColumn returns a new index annotation with column prefix for multi-column indexes. In MySQL, the following annotation maps to:

index.Fields("c1", "c2", "c3").
	Annotation(
		fluent_sql.PrefixColumn("c1", 100),
		fluent_sql.PrefixColumn("c2", 200),
	)

CREATE INDEX `table_c1_c2_c3` ON `table`(`c1`(100), `c2`(200), `c3`)

func (IndexAnnotation) Merge

func (a IndexAnnotation) Merge(other schema.Annotation) schema.Annotation

Merge implements the schema.Merger interface.

func (IndexAnnotation) Name

func (IndexAnnotation) Name() string

Name describes the annotation name.

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.