pqt

type Attribute struct {
	Name, Collate, Default, Check string
	NotNull, Unique, PrimaryKey   bool
	Schema                        *Schema
	Type                          Type
}

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

type Column struct {
	// Name is a column name.
	Name string
	// ShortName is a column short name. It is used in queries when column name is ambiguous.
	ShortName string
	// Collate is a collation for column.
	// It allows to specify the collation order for character data.
	Collate string
	// Check is a check constraint.
	// It allows to specify a predicate that must be satisfied by each row of the table.
	Check string
	// Default is a default value for column for given event.
	// For example for insert event it will be used when no value is provided.
	Default map[Event]string
	// NotNull if true means that column cannot be null.
	NotNull bool
	// Unique if true means that column value must be unique.
	Unique bool
	// PrimaryKey if true means that column is a primary key.
	PrimaryKey bool
	// Index if true means that column is indexed.
	Index bool
	// Type is a column type.
	Type Type
	// Table is a table that column belongs to.
	Table *Table
	// Reference is a column that this column references.
	Reference *Column
	// ReferenceOptions are options for reference.
	ReferenceOptions []RelationshipOption
	// Match is a match option for foreign key constraint.
	Match int32
	// OnDelete is a ON DELETE clause that specifies the action to perform when a referenced row in the referenced table is being deleted.
	OnDelete int32
	// OnUpdate is a ON UPDATE clause that specifies the action to perform when a referenced column in the referenced table is being updated to a new value.
	OnUpdate int32
	// NoInherit if true means that column is not inherited by child tables.
	NoInherit                    bool
	DeferrableInitiallyDeferred  bool
	DeferrableInitiallyImmediate bool
	// IsDynamic if true means that column is not stored in database, but is dynamically created using function.
	IsDynamic bool
	// Func is a function that is used to create dynamic column.
	Func *Function
	// Columns are columns that are used by dynamic column function.
	Columns Columns
}

type ColumnOption func(*Column)

type Columns []*Column

type CompositeType struct {
	Attributes []*Attribute
	// contains filtered or unexported fields
}

type Constraint struct {
	Type                                                                 ConstraintType
	Where, Check                                                         string
	PrimaryTable, Table                                                  *Table
	PrimaryColumns, Columns                                              Columns
	Attribute                                                            []*Attribute
	Match, OnDelete, OnUpdate                                            int32
	NoInherit, DeferrableInitiallyDeferred, DeferrableInitiallyImmediate bool
	MethodSuffix                                                         string
}

type ConstraintOption func(*Constraint)

type ConstraintType string

type Constraints []*Constraint

type EnumeratedType struct {
	Enums []string
	// contains filtered or unexported fields
}

type Event string

type Function struct {
	Name      string
	BuiltIn   bool
	Type      Type
	Body      string
	Behaviour FunctionBehaviour
	Args      []*FunctionArg
}

type FunctionArg struct {
	Name string
	Type Type
}

type FunctionBehaviour int

type MappableType struct {
	From    Type
	Mapping []Type
}

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

type Reference struct {
	From, To *Column
}

type Relationship struct {
	// Bidirectional if true means that relationship is bidirectional.
	// It is useful when we want to get all related rows from both tables.
	// If true, the library will generate additional methods for both tables.
	Bidirectional bool
	// Type defines relationship type.
	Type RelationshipType
	// OwnerName is a name of relationship from owner table perspective.
	// For example if we have table A and table B and relationship from A to B,
	// then owner name is a name of relationship from A perspective.
	// It is a good practice to give descriptive names to relationships.
	OwnerName string
	// InversedName is a name of relationship from inversed table perspective.
	// For example if we have table A and table B and relationship from A to B,
	// then inversed name is a name of relationship from B perspective.
	// If not set, the library will generate it automatically.
	// It is useful when we want to have two relationships between two tables or when table self references itself.
	// It is a good practice to give descriptive names to relationships.
	InversedName                            string
	OwnerTable, InversedTable, ThroughTable *Table
	OwnerForeignKey, InversedForeignKey     *Constraint
	OwnerColumns, InversedColumns           Columns
	ColumnName                              string
	OnDelete, OnUpdate                      int32
}

type RelationshipOption func(*Relationship)

type RelationshipType int

type Schema struct {
	// Name is a schema name.
	Name string
	// IfNotExists if true means that schema should be created only if it does not exist.
	// If true, creation process will not fail if schema already exists.
	IfNotExists bool
	// Tables is a collection of tables that schema contains.
	Tables []*Table
	// Functions is a collection of functions that schema contains.
	Functions []*Function
	// Types is a collection of types that schema contains.
	Types []Type
}

type SchemaOption func(*Schema)

type Table struct {
	Name, ShortName, Collate, TableSpace string
	IfNotExists, Temporary               bool
	// Schema references parent schema.
	Schema *Schema
	// Columns is a collection of columns that table contains.
	Columns Columns
	// Constraints is a collection of constraints that table contains.
	Constraints Constraints
	// OwnedRelationships is a collection of relationships that table owns.
	OwnedRelationships []*Relationship
	// InversedRelationships is a collection of relationships that table is inversed in.
	InversedRelationships []*Relationship
	// ManyToManyRelationships is a collection of relationships that table is inversed in.
	ManyToManyRelationships []*Relationship
	// contains filtered or unexported fields
}

type TableOption func(*Table)

type Type interface {
	fmt.Stringer
	// Fingerprint returns unique identifier of the type. Two different types can have same SQL representation.
	Fingerprint() string
}