Documentation ¶
Index ¶
- Constants
- Variables
- func FormatType(t schema.Type) (string, error)
- func MarshalSpec(v any, marshaler schemahcl.Marshaler) ([]byte, error)
- func Open(db schema.ExecQuerier) (migrate.Driver, error)
- func ParseType(typ string) (schema.Type, error)
- type ArrayType
- type BitType
- type CType
- type Cascade
- type CheckColumns
- type Concurrently
- type Constraint
- type CurrencyType
- type Driver
- func (d *Driver) CheckClean(ctx context.Context, revT *migrate.TableIdent) error
- func (d *Driver) Lock(ctx context.Context, name string, timeout time.Duration) (schema.UnlockFunc, error)
- func (d *Driver) NormalizeRealm(ctx context.Context, r *schema.Realm) (*schema.Realm, error)
- func (d *Driver) NormalizeSchema(ctx context.Context, s *schema.Schema) (*schema.Schema, error)
- func (d *Driver) Snapshot(ctx context.Context) (migrate.RestoreFunc, error)
- func (d *Driver) Version() string
- type Enum
- type Identity
- type IndexColumnProperty
- type IndexInclude
- type IndexOpClass
- type IndexPredicate
- type IndexStorageParams
- type IndexType
- type IntervalType
- type NetworkType
- type NoInherit
- type OIDType
- type Partition
- type PartitionPart
- type RangeType
- type Sequence
- type SerialType
- type TextSearchType
- type UUIDType
- type UserDefinedType
- type XMLType
Constants ¶
const ( TypeInt64 = "int64" TypeGeometry = "geometry" )
CockroachDB types that are not part of PostgreSQL.
const ( TypeBit = "bit" TypeBitVar = "bit varying" TypeBoolean = "boolean" TypeBool = "bool" // boolean. TypeBytea = "bytea" TypeCharacter = "character" TypeChar = "char" // character TypeCharVar = "character varying" TypeVarChar = "varchar" // character varying TypeText = "text" TypeSmallInt = "smallint" TypeInteger = "integer" TypeBigInt = "bigint" TypeInt = "int" // integer. TypeInt2 = "int2" // smallint. TypeInt4 = "int4" // integer. TypeInt8 = "int8" // bigint. TypeCIDR = "cidr" TypeInet = "inet" TypeMACAddr = "macaddr" TypeMACAddr8 = "macaddr8" TypeCircle = "circle" TypeLine = "line" TypeLseg = "lseg" TypeBox = "box" TypePath = "path" TypePolygon = "polygon" TypePoint = "point" TypeDate = "date" TypeTime = "time" // time without time zone TypeTimeTZ = "timetz" // time with time zone TypeTimeWTZ = "time with time zone" TypeTimeWOTZ = "time without time zone" TypeTimestamp = "timestamp" // timestamp without time zone TypeTimestampTZ = "timestamptz" TypeTimestampWTZ = "timestamp with time zone" TypeTimestampWOTZ = "timestamp without time zone" TypeDouble = "double precision" TypeReal = "real" TypeFloat8 = "float8" // double precision TypeFloat4 = "float4" // real TypeFloat = "float" // float(p). TypeNumeric = "numeric" TypeDecimal = "decimal" // numeric TypeSmallSerial = "smallserial" // smallint with auto_increment. TypeSerial = "serial" // integer with auto_increment. TypeBigSerial = "bigserial" // bigint with auto_increment. TypeSerial2 = "serial2" // smallserial TypeSerial4 = "serial4" // serial TypeSerial8 = "serial8" // bigserial TypeArray = "array" TypeXML = "xml" TypeJSON = "json" TypeJSONB = "jsonb" TypeUUID = "uuid" TypeMoney = "money" TypeInterval = "interval" TypeTSQuery = "tsquery" TypeTSVector = "tsvector" TypeUserDefined = "user-defined" TypeInt4Range = "int4range" TypeInt4MultiRange = "int4multirange" TypeInt8Range = "int8range" TypeInt8MultiRange = "int8multirange" TypeNumRange = "numrange" TypeNumMultiRange = "nummultirange" TypeTSRange = "tsrange" TypeTSMultiRange = "tsmultirange" TypeTSTZRange = "tstzrange" TypeTSTZMultiRange = "tstzmultirange" TypeDateRange = "daterange" TypeDateMultiRange = "datemultirange" )
Standard column types (and their aliases) as defined in PostgreSQL codebase/website.
const ( IndexTypeBTree = "BTREE" IndexTypeBRIN = "BRIN" IndexTypeHash = "HASH" IndexTypeGIN = "GIN" IndexTypeGiST = "GIST" IndexTypeSPGiST = "SPGIST" )
List of supported index types.
const ( GeneratedTypeAlways = "ALWAYS" GeneratedTypeByDefault = "BY_DEFAULT" // BY DEFAULT. )
List of "GENERATED" types.
const ( PartitionTypeRange = "RANGE" PartitionTypeList = "LIST" PartitionTypeHash = "HASH" )
List of PARTITION KEY types.
const DriverName = "postgres"
DriverName holds the name used for registration.
Variables ¶
var ( // MarshalHCL marshals v into an Atlas HCL DDL document. MarshalHCL = schemahcl.MarshalerFunc(func(v any) ([]byte, error) { return MarshalSpec(v, hclState) }) // EvalHCL implements the schemahcl.Evaluator interface. EvalHCL = schemahcl.EvalFunc(evalSpec) // EvalHCLBytes is a helper that evaluates an HCL document from a byte slice instead // of from an hclparse.Parser instance. EvalHCLBytes = specutil.HCLBytesFunc(EvalHCL) )
var DefaultDiff schema.Differ = &sqlx.Diff{DiffDriver: &diff{}}
DefaultDiff provides basic diffing capabilities for PostgreSQL dialects. Note, it is recommended to call Open, create a new Driver and use its Differ when a database connection is available.
var DefaultPlan migrate.PlanApplier = &planApply{conn: conn{ExecQuerier: sqlx.NoRows}}
DefaultPlan provides basic planning capabilities for PostgreSQL dialects. Note, it is recommended to call Open, create a new Driver and use its migrate.PlanApplier when a database connection is available.
var TypeRegistry = schemahcl.NewRegistry( schemahcl.WithSpecFunc(typeSpec), schemahcl.WithParser(ParseType), schemahcl.WithSpecs( schemahcl.NewTypeSpec(TypeBit, schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "len", Kind: reflect.Int64})), schemahcl.AliasTypeSpec("bit_varying", TypeBitVar, schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "len", Kind: reflect.Int64})), schemahcl.NewTypeSpec(TypeVarChar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))), schemahcl.AliasTypeSpec("character_varying", TypeCharVar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))), schemahcl.NewTypeSpec(TypeChar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))), schemahcl.NewTypeSpec(TypeCharacter, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))), schemahcl.NewTypeSpec(TypeInt2), schemahcl.NewTypeSpec(TypeInt4), schemahcl.NewTypeSpec(TypeInt8), schemahcl.NewTypeSpec(TypeInt), schemahcl.NewTypeSpec(TypeInteger), schemahcl.NewTypeSpec(TypeSmallInt), schemahcl.NewTypeSpec(TypeBigInt), schemahcl.NewTypeSpec(TypeText), schemahcl.NewTypeSpec(TypeBoolean), schemahcl.NewTypeSpec(TypeBool), schemahcl.NewTypeSpec(TypeBytea), schemahcl.NewTypeSpec(TypeCIDR), schemahcl.NewTypeSpec(TypeInet), schemahcl.NewTypeSpec(TypeMACAddr), schemahcl.NewTypeSpec(TypeMACAddr8), schemahcl.NewTypeSpec(TypeCircle), schemahcl.NewTypeSpec(TypeLine), schemahcl.NewTypeSpec(TypeLseg), schemahcl.NewTypeSpec(TypeBox), schemahcl.NewTypeSpec(TypePath), schemahcl.NewTypeSpec(TypePoint), schemahcl.NewTypeSpec(TypePolygon), schemahcl.NewTypeSpec(TypeDate), schemahcl.NewTypeSpec(TypeTime, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()), schemahcl.NewTypeSpec(TypeTimeTZ, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()), schemahcl.NewTypeSpec(TypeTimestampTZ, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()), schemahcl.NewTypeSpec(TypeTimestamp, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()), schemahcl.AliasTypeSpec("double_precision", TypeDouble), schemahcl.NewTypeSpec(TypeReal), schemahcl.NewTypeSpec(TypeFloat, schemahcl.WithAttributes(precisionTypeAttr())), schemahcl.NewTypeSpec(TypeFloat8), schemahcl.NewTypeSpec(TypeFloat4), schemahcl.NewTypeSpec(TypeNumeric, schemahcl.WithAttributes(precisionTypeAttr(), &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})), schemahcl.NewTypeSpec(TypeDecimal, schemahcl.WithAttributes(precisionTypeAttr(), &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})), schemahcl.NewTypeSpec(TypeSmallSerial), schemahcl.NewTypeSpec(TypeSerial), schemahcl.NewTypeSpec(TypeBigSerial), schemahcl.NewTypeSpec(TypeSerial2), schemahcl.NewTypeSpec(TypeSerial4), schemahcl.NewTypeSpec(TypeSerial8), schemahcl.NewTypeSpec(TypeXML), schemahcl.NewTypeSpec(TypeJSON), schemahcl.NewTypeSpec(TypeJSONB), schemahcl.NewTypeSpec(TypeUUID), schemahcl.NewTypeSpec(TypeMoney), schemahcl.NewTypeSpec(TypeTSVector), schemahcl.NewTypeSpec(TypeTSQuery), schemahcl.NewTypeSpec(TypeInt4Range), schemahcl.NewTypeSpec(TypeInt4MultiRange), schemahcl.NewTypeSpec(TypeInt8Range), schemahcl.NewTypeSpec(TypeInt8MultiRange), schemahcl.NewTypeSpec(TypeNumRange), schemahcl.NewTypeSpec(TypeNumMultiRange), schemahcl.NewTypeSpec(TypeTSRange), schemahcl.NewTypeSpec(TypeTSMultiRange), schemahcl.NewTypeSpec(TypeTSTZRange), schemahcl.NewTypeSpec(TypeTSTZMultiRange), schemahcl.NewTypeSpec(TypeDateRange), schemahcl.NewTypeSpec(TypeDateMultiRange), schemahcl.NewTypeSpec("hstore"), schemahcl.NewTypeSpec("sql", schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "def", Required: true, Kind: reflect.String})), ), schemahcl.WithSpecs(func() (specs []*schemahcl.TypeSpec) { for _, t := range []string{ typeOID, typeRegClass, typeRegCollation, typeRegConfig, typeRegDictionary, typeRegNamespace, typeName, typeRegOper, typeRegOperator, typeRegProc, typeRegProcedure, typeRegRole, typeRegType, } { specs = append(specs, schemahcl.NewTypeSpec(t)) } return specs }()...), schemahcl.WithSpecs(func() (specs []*schemahcl.TypeSpec) { opts := []schemahcl.TypeSpecOption{ schemahcl.WithToSpec(func(t schema.Type) (*schemahcl.Type, error) { i, ok := t.(*IntervalType) if !ok { return nil, fmt.Errorf("postgres: unexpected interval type %T", t) } spec := &schemahcl.Type{T: TypeInterval} if i.F != "" { spec.T = specutil.Var(strings.ToLower(i.F)) } if p := i.Precision; p != nil && *p != defaultTimePrecision { spec.Attrs = []*schemahcl.Attr{schemahcl.IntAttr("precision", *p)} } return spec, nil }), schemahcl.WithFromSpec(func(t *schemahcl.Type) (schema.Type, error) { i := &IntervalType{T: TypeInterval} if t.T != TypeInterval { i.F = specutil.FromVar(t.T) } if a, ok := attr(t, "precision"); ok { p, err := a.Int() if err != nil { return nil, fmt.Errorf(`postgres: parsing attribute "precision": %w`, err) } if p != defaultTimePrecision { i.Precision = &p } } return i, nil }), } for _, f := range []string{"interval", "second", "day to second", "hour to second", "minute to second"} { specs = append(specs, schemahcl.NewTypeSpec(specutil.Var(f), append(opts, schemahcl.WithAttributes(precisionTypeAttr()))...)) } for _, f := range []string{"year", "month", "day", "hour", "minute", "year to month", "day to hour", "day to minute", "hour to minute"} { specs = append(specs, schemahcl.NewTypeSpec(specutil.Var(f), opts...)) } return specs }()...), )
TypeRegistry contains the supported TypeSpecs for the Postgres driver.
Functions ¶
func FormatType ¶ added in v0.2.0
FormatType converts schema type to its column form in the database. An error is returned if the type cannot be recognized.
func MarshalSpec ¶
MarshalSpec marshals v into an Atlas DDL document using a schemahcl.Marshaler.
Types ¶
type ArrayType ¶
type ArrayType struct { schema.Type // Underlying items type (e.g. varchar(255)). T string // Formatted type (e.g. int[]). }
ArrayType defines an array type. https://postgresql.org/docs/current/arrays.html
type BitType ¶
BitType defines a bit type. https://postgresql.org/docs/current/datatype-bit.html
type Cascade ¶ added in v0.3.7
Cascade describes that a CASCADE clause should be added to the DROP [TABLE|SCHEMA] operation. Note, this clause is automatically added to DROP SCHEMA by the planner.
type CheckColumns ¶ added in v0.2.0
CheckColumns attribute hold the column named used by the CHECK constraints. This attribute is added on inspection for internal usage and has no meaning on migration.
type Concurrently ¶ added in v0.7.1
Concurrently describes the CONCURRENTLY clause to instruct Postgres to build or drop the index concurrently without blocking the current table. https://www.postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY
type Constraint ¶ added in v0.8.3
Constraint describes a postgres constraint. https://postgresql.org/docs/current/catalog-pg-constraint.html
func (Constraint) IsUnique ¶ added in v0.8.3
func (c Constraint) IsUnique() bool
IsUnique reports if the type is unique constraint.
type CurrencyType ¶
A CurrencyType defines a currency type.
type Driver ¶
type Driver struct { schema.Differ schema.Inspector migrate.PlanApplier // contains filtered or unexported fields }
Driver represents a PostgreSQL driver for introspecting database schemas, generating diff between schema elements and apply migrations changes.
func (*Driver) CheckClean ¶ added in v0.6.0
CheckClean implements migrate.CleanChecker.
func (*Driver) Lock ¶ added in v0.3.8
func (d *Driver) Lock(ctx context.Context, name string, timeout time.Duration) (schema.UnlockFunc, error)
Lock implements the schema.Locker interface.
func (*Driver) NormalizeRealm ¶ added in v0.3.7
NormalizeRealm returns the normal representation of the given database.
func (*Driver) NormalizeSchema ¶ added in v0.3.7
NormalizeSchema returns the normal representation of the given database.
type Enum ¶ added in v0.3.1
type Enum struct { Name string `spec:",name"` Schema *schemahcl.Ref `spec:"schema"` Values []string `spec:"values"` schemahcl.DefaultExtension }
Enum holds a specification for an enum, that can be referenced as a column type.
type IndexColumnProperty ¶
type IndexColumnProperty struct { schema.Attr // NullsFirst defaults to true for DESC indexes. NullsFirst bool // NullsLast defaults to true for ASC indexes. NullsLast bool }
IndexColumnProperty describes an index column property. https://postgresql.org/docs/current/functions-info.html#FUNCTIONS-INFO-INDEX-COLUMN-PROPS
type IndexInclude ¶ added in v0.6.5
IndexInclude describes the INCLUDE clause allows specifying a list of column which added to the index as non-key columns. https://www.postgresql.org/docs/current/sql-createindex.html
type IndexOpClass ¶ added in v0.8.2
type IndexOpClass struct { schema.Attr Name string // Name of the operator class. Default bool // If it is the default operator class. Params []struct{ N, V string } // Optional parameters. }
IndexOpClass describers operator class of the index part. https://www.postgresql.org/docs/current/indexes-opclass.html.
func (*IndexOpClass) DefaultFor ¶ added in v0.8.2
DefaultFor reports if the operator_class is the default for the index part.
func (*IndexOpClass) Equal ¶ added in v0.8.2
func (o *IndexOpClass) Equal(x *IndexOpClass) bool
Equal reports whether o and x are the same operator class.
func (*IndexOpClass) String ¶ added in v0.8.2
func (o *IndexOpClass) String() string
String returns the string representation of the operator class.
func (*IndexOpClass) UnmarshalText ¶ added in v0.8.2
func (o *IndexOpClass) UnmarshalText(text []byte) error
UnmarshalText parses the operator class from its string representation.
type IndexPredicate ¶
IndexPredicate describes a partial index predicate. https://postgresql.org/docs/current/catalog-pg-index.html
type IndexStorageParams ¶ added in v0.4.0
type IndexStorageParams struct { schema.Attr // AutoSummarize defines the authsummarize storage parameter. AutoSummarize bool // PagesPerRange defines pages_per_range storage // parameter for BRIN indexes. Defaults to 128. PagesPerRange int64 }
IndexStorageParams describes index storage parameters add with the WITH clause. https://postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-STORAGE-PARAMETERS
type IndexType ¶
IndexType represents an index type. https://postgresql.org/docs/current/indexes-types.html
type IntervalType ¶ added in v0.4.3
type IntervalType struct { schema.Type T string // Type name. F string // Optional field. YEAR, MONTH, ..., MINUTE TO SECOND. Precision *int // Optional precision. }
IntervalType defines an interval type. https://postgresql.org/docs/current/datatype-datetime.html
type NetworkType ¶
A NetworkType defines a network type. https://postgresql.org/docs/current/datatype-net-types.html
type NoInherit ¶ added in v0.2.0
NoInherit attribute defines the NO INHERIT flag for CHECK constraint. https://postgresql.org/docs/current/catalog-pg-constraint.html
type Partition ¶ added in v0.3.8
type Partition struct { schema.Attr // T defines the type/strategy of the partition. // Can be one of: RANGE, LIST, HASH. T string // Partition parts. The additional attributes // on each part can be used to control collation. Parts []*PartitionPart // contains filtered or unexported fields }
Partition defines the spec of a partitioned table.
type PartitionPart ¶ added in v0.3.8
An PartitionPart represents an index part that can be either an expression or a column.
type RangeType ¶ added in v0.9.0
A RangeType defines a range type. https://www.postgresql.org/docs/current/rangetypes.html
type Sequence ¶ added in v0.2.0
type Sequence struct {
Start, Increment int64
// Last sequence value written to disk.
// https://postgresql.org/docs/current/view-pg-sequences.html.
Last int64
}
Sequence defines (the supported) sequence options. https://postgresql.org/docs/current/sql-createsequence.html
type SerialType ¶
type SerialType struct { schema.Type T string Precision int // SequenceName holds the inspected sequence name attached to the column. // It defaults to <Table>_<Column>_seq when the column is created, but may // be different in case the table or the column was renamed. SequenceName string }
A SerialType defines a serial type. https://postgresql.org/docs/current/datatype-numeric.html#DATATYPE-SERIAL
func (*SerialType) IntegerType ¶ added in v0.6.0
func (s *SerialType) IntegerType() *schema.IntegerType
IntegerType returns the underlying integer type this serial type represents.
func (*SerialType) SetType ¶ added in v0.6.0
func (s *SerialType) SetType(t *schema.IntegerType)
SetType sets the serial type from the given integer type.
type TextSearchType ¶ added in v0.8.2
A TextSearchType defines full text search types. https://www.postgresql.org/docs/current/datatype-textsearch.html
type UUIDType ¶
UUIDType is alias to schema.UUIDType. Defined here for backward compatibility reasons.
type UserDefinedType ¶
UserDefinedType defines a user-defined type attribute.