models

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 28, 2025 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Overview

Package models provides the core data structures for representing database schemas. It defines types for databases, schemas, tables, columns, relationships, constraints, indexes, views, sequences, and other database objects. These models serve as the intermediate representation for converting between various database schema formats.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Column 

type Column struct {
	Name          string `json:"name" yaml:"name" xml:"name"`
	Description   string `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Table         string `json:"table" yaml:"table" xml:"table"`
	Schema        string `json:"schema" yaml:"schema" xml:"schema"`
	Type          string `json:"type" yaml:"type" xml:"type"`
	Length        int    `json:"length,omitempty" yaml:"length,omitempty" xml:"length,omitempty"`
	Precision     int    `json:"precision,omitempty" yaml:"precision,omitempty" xml:"precision,omitempty"`
	Scale         int    `json:"scale,omitempty" yaml:"scale,omitempty" xml:"scale,omitempty"`
	NotNull       bool   `json:"not_null" yaml:"not_null" xml:"not_null"`
	Default       any    `json:"default,omitempty" yaml:"default,omitempty" xml:"default,omitempty"`
	AutoIncrement bool   `json:"auto_increment" yaml:"auto_increment" xml:"auto_increment"`
	IsPrimaryKey  bool   `json:"is_primary_key" yaml:"is_primary_key" xml:"is_primary_key"`
	Comment       string `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Collation     string `json:"collation,omitempty" yaml:"collation,omitempty" xml:"collation,omitempty"`
	Sequence      uint   `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
}

Column represents a table column

func InitColumn 

func InitColumn(name, table, schema string) *Column

InitColumn initializes a new Column

func (*Column) SQLName 

func (d *Column) SQLName() string

SQLName returns the column name in lowercase for SQL compatibility.

type Constraint 

type Constraint struct {
	Name              string         `json:"name" yaml:"name" xml:"name"`
	Type              ConstraintType `json:"type" yaml:"type" xml:"type"`
	Columns           []string       `json:"columns" yaml:"columns" xml:"columns"`
	Expression        string         `json:"expression,omitempty" yaml:"expression,omitempty" xml:"expression,omitempty"`
	Schema            string         `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
	Table             string         `json:"table,omitempty" yaml:"table,omitempty" xml:"table,omitempty"`
	ReferencedTable   string         `json:"referenced_table" yaml:"referenced_table" xml:"referenced_table"`
	ReferencedSchema  string         `json:"referenced_schema" yaml:"referenced_schema" xml:"referenced_schema"`
	ReferencedColumns []string       `json:"referenced_columns" yaml:"referenced_columns" xml:"referenced_columns"`
	OnDelete          string         `json:"on_delete" yaml:"on_delete" xml:"on_delete"` // CASCADE, SET NULL, RESTRICT, etc.
	OnUpdate          string         `json:"on_update" yaml:"on_update" xml:"on_update"`
	Deferrable        bool           `json:"deferrable,omitempty" yaml:"deferrable,omitempty" xml:"deferrable,omitempty"`
	InitiallyDeferred bool           `json:"initially_deferred,omitempty" yaml:"initially_deferred,omitempty" xml:"initially_deferred,omitempty"`
	Sequence          uint           `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
}

Constraint represents a database constraint that enforces data integrity rules. Constraints can be primary keys, foreign keys, unique constraints, check constraints, or not-null constraints.

func InitConstraint 

func InitConstraint(name string, constraintType ConstraintType) *Constraint

InitConstraint initializes a new Constraint with empty slices

func (*Constraint) SQLName 

func (d *Constraint) SQLName() string

SQLName returns the constraint name in lowercase for SQL compatibility.

type ConstraintType 

type ConstraintType string

ConstraintType represents the type of database constraint. 

const (
	PrimaryKeyConstraint ConstraintType = "primary_key" // Primary key uniquely identifies each record
	ForeignKeyConstraint ConstraintType = "foreign_key" // Foreign key references another table
	UniqueConstraint     ConstraintType = "unique"      // Unique constraint ensures all values are different
	CheckConstraint      ConstraintType = "check"       // Check constraint validates data against an expression
	NotNullConstraint    ConstraintType = "not_null"    // Not null constraint requires a value
)

Supported constraint types.

type DCTXComponent 

type DCTXComponent struct {
	Guid    string `xml:"Guid,attr"`
	FieldId string `xml:"FieldId,attr,omitempty"`
	Order   int    `xml:"Order,attr"`
	Ascend  bool   `xml:"Ascend,attr,omitempty"`
}

DCTXComponent represents a component of a key, referencing a field in the index.

type DCTXDictionary 

type DCTXDictionary struct {
	XMLName   xml.Name       `xml:"Dictionary"`
	Name      string         `xml:"Name,attr"`
	Version   string         `xml:"Version,attr"`
	Tables    []DCTXTable    `xml:"Table"`
	Relations []DCTXRelation `xml:"Relation,omitempty"`
}

DCTXDictionary represents the root element of a DCTX file.

type DCTXField 

type DCTXField struct {
	Guid       string       `xml:"Guid,attr"`
	Name       string       `xml:"Name,attr"`
	DataType   string       `xml:"DataType,attr"`
	Size       int          `xml:"Size,attr,omitempty"`
	NoPopulate bool         `xml:"NoPopulate,attr,omitempty"`
	Thread     bool         `xml:"Thread,attr,omitempty"`
	Fields     []DCTXField  `xml:"Field,omitempty"` // For GROUP fields (nested structures)
	Options    []DCTXOption `xml:"Option,omitempty"`
}

DCTXField represents a field/column definition in DCTX format. Fields can be nested for GROUP structures.

type DCTXFieldMapping 

type DCTXFieldMapping struct {
	Guid  string `xml:"Guid,attr"`
	Field string `xml:"Field,attr"`
}

DCTXFieldMapping represents a field mapping in a relation for multi-column foreign keys.

type DCTXKey 

type DCTXKey struct {
	Guid        string          `xml:"Guid,attr"`
	Name        string          `xml:"Name,attr"`
	KeyType     string          `xml:"KeyType,attr,omitempty"`
	Primary     bool            `xml:"Primary,attr,omitempty"`
	Unique      bool            `xml:"Unique,attr,omitempty"`
	Order       int             `xml:"Order,attr,omitempty"`
	Description string          `xml:"Description,attr,omitempty"`
	Components  []DCTXComponent `xml:"Component"`
}

DCTXKey represents an index or key definition in DCTX format.

type DCTXOption 

type DCTXOption struct {
	Property      string `xml:"Property,attr"`
	PropertyType  string `xml:"PropertyType,attr,omitempty"`
	PropertyValue string `xml:"PropertyValue,attr"`
}

DCTXOption represents a property option in DCTX format for metadata storage.

type DCTXRelation 

type DCTXRelation struct {
	Guid            string             `xml:"Guid,attr"`
	PrimaryTable    string             `xml:"PrimaryTable,attr"`
	ForeignTable    string             `xml:"ForeignTable,attr"`
	PrimaryKey      string             `xml:"PrimaryKey,attr,omitempty"`
	ForeignKey      string             `xml:"ForeignKey,attr,omitempty"`
	Delete          string             `xml:"Delete,attr,omitempty"`
	Update          string             `xml:"Update,attr,omitempty"`
	ForeignMappings []DCTXFieldMapping `xml:"ForeignMapping,omitempty"`
	PrimaryMappings []DCTXFieldMapping `xml:"PrimaryMapping,omitempty"`
}

DCTXRelation represents a relationship/foreign key in DCTX format.

type DCTXTable 

type DCTXTable struct {
	Guid        string       `xml:"Guid,attr"`
	Name        string       `xml:"Name,attr"`
	Prefix      string       `xml:"Prefix,attr"`
	Driver      string       `xml:"Driver,attr,omitempty"`
	Owner       string       `xml:"Owner,attr,omitempty"`
	Path        string       `xml:"Path,attr,omitempty"`
	Description string       `xml:"Description,attr,omitempty"`
	Fields      []DCTXField  `xml:"Field"`
	Keys        []DCTXKey    `xml:"Key,omitempty"`
	Options     []DCTXOption `xml:"Option,omitempty"`
}

DCTXTable represents a table definition in DCTX format.

type Database 

type Database struct {
	Name            string       `json:"name" yaml:"name"`
	Description     string       `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Schemas         []*Schema    `json:"schemas" yaml:"schemas" xml:"schemas"`
	Comment         string       `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	DatabaseType    DatabaseType `json:"database_type,omitempty" yaml:"database_type,omitempty" xml:"database_type,omitempty"`
	DatabaseVersion string       `json:"database_version,omitempty" yaml:"database_version,omitempty" xml:"database_version,omitempty"`
	SourceFormat    string       `json:"source_format,omitempty" yaml:"source_format,omitempty" xml:"source_format,omitempty"` // Source Format of the database.
}

Database represents the complete database schema

func InitDatabase 

func InitDatabase(name string) *Database

InitDatabase initializes a new Database with empty slices

func (*Database) SQLName 

func (d *Database) SQLName() string

SQLName returns the database name in lowercase for SQL compatibility.

func (*Database) ToFlatColumns 

func (d *Database) ToFlatColumns() []*FlatColumn

ToFlatColumns converts a Database to a slice of FlatColumns for denormalized access to all columns.

func (*Database) ToFlatConstraints 

func (d *Database) ToFlatConstraints() []*FlatConstraint

ToFlatConstraints converts a Database to a slice of FlatConstraints for denormalized access to all constraints.

func (*Database) ToFlatRelationships 

func (d *Database) ToFlatRelationships() []*FlatRelationship

ToFlatRelationships converts a Database to a slice of FlatRelationships for denormalized access to all relationships.

func (*Database) ToFlatTables 

func (d *Database) ToFlatTables() []*FlatTable

ToFlatTables converts a Database to a slice of FlatTables for denormalized access to all tables.

func (*Database) ToSummary 

func (d *Database) ToSummary() *DatabaseSummary

ToSummary converts a Database to a DatabaseSummary with calculated counts.

type DatabaseSummary 

type DatabaseSummary struct {
	Name            string       `json:"name" yaml:"name" xml:"name"`
	Description     string       `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	DatabaseType    DatabaseType `json:"database_type,omitempty" yaml:"database_type,omitempty" xml:"database_type,omitempty"`
	DatabaseVersion string       `json:"database_version,omitempty" yaml:"database_version,omitempty" xml:"database_version,omitempty"`
	SchemaCount     int          `json:"schema_count" yaml:"schema_count" xml:"schema_count"`
	TotalTables     int          `json:"total_tables" yaml:"total_tables" xml:"total_tables"`
	TotalColumns    int          `json:"total_columns" yaml:"total_columns" xml:"total_columns"`
}

DatabaseSummary provides a compact overview of a database with aggregated statistics.

type DatabaseType 

type DatabaseType string

DatabaseType represents the type of database system. 

const (
	PostgresqlDatabaseType DatabaseType = "pgsql"  // PostgreSQL database
	MSSQLDatabaseType      DatabaseType = "mssql"  // Microsoft SQL Server database
	SqlLiteDatabaseType    DatabaseType = "sqlite" // SQLite database
)

Supported database types.

type Enum added in v1.0.2 

type Enum struct {
	Name   string   `json:"name" yaml:"name" xml:"name"`
	Values []string `json:"values" yaml:"values" xml:"values"`
	Schema string   `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
}

Enum represents a database enumeration type with a set of allowed values.

func (*Enum) SQLName added in v1.0.2 

func (d *Enum) SQLName() string

SQLName returns the enum name in lowercase for SQL compatibility.

type FlatColumn 

type FlatColumn struct {
	DatabaseName       string `json:"database_name" yaml:"database_name" xml:"database_name"`
	SchemaName         string `json:"schema_name" yaml:"schema_name" xml:"schema_name"`
	TableName          string `json:"table_name" yaml:"table_name" xml:"table_name"`
	ColumnName         string `json:"column_name" yaml:"column_name" xml:"column_name"`
	FullyQualifiedName string `json:"fully_qualified_name" yaml:"fully_qualified_name" xml:"fully_qualified_name"` // database.schema.table.column
	Type               string `json:"type" yaml:"type" xml:"type"`
	Length             int    `json:"length,omitempty" yaml:"length,omitempty" xml:"length,omitempty"`
	Precision          int    `json:"precision,omitempty" yaml:"precision,omitempty" xml:"precision,omitempty"`
	Scale              int    `json:"scale,omitempty" yaml:"scale,omitempty" xml:"scale,omitempty"`
	NotNull            bool   `json:"not_null" yaml:"not_null" xml:"not_null"`
	Default            any    `json:"default,omitempty" yaml:"default,omitempty" xml:"default,omitempty"`
	AutoIncrement      bool   `json:"auto_increment" yaml:"auto_increment" xml:"auto_increment"`
	IsPrimaryKey       bool   `json:"is_primary_key" yaml:"is_primary_key" xml:"is_primary_key"`
	Description        string `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Comment            string `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
}

FlatColumn represents a column with full database context in a single structure. It includes fully qualified names for easy identification and querying.

type FlatConstraint 

type FlatConstraint struct {
	DatabaseName       string         `json:"database_name" yaml:"database_name" xml:"database_name"`
	SchemaName         string         `json:"schema_name" yaml:"schema_name" xml:"schema_name"`
	TableName          string         `json:"table_name" yaml:"table_name" xml:"table_name"`
	ConstraintName     string         `json:"constraint_name" yaml:"constraint_name" xml:"constraint_name"`
	FullyQualifiedName string         `json:"fully_qualified_name" yaml:"fully_qualified_name" xml:"fully_qualified_name"` // database.schema.table.constraint
	Type               ConstraintType `json:"type" yaml:"type" xml:"type"`
	Columns            []string       `json:"columns" yaml:"columns" xml:"columns"`
	Expression         string         `json:"expression,omitempty" yaml:"expression,omitempty" xml:"expression,omitempty"`
	ReferencedTable    string         `json:"referenced_table,omitempty" yaml:"referenced_table,omitempty" xml:"referenced_table,omitempty"`
	ReferencedSchema   string         `json:"referenced_schema,omitempty" yaml:"referenced_schema,omitempty" xml:"referenced_schema,omitempty"`
	ReferencedColumns  []string       `json:"referenced_columns,omitempty" yaml:"referenced_columns,omitempty" xml:"referenced_columns,omitempty"`
	ReferencedFQN      string         `json:"referenced_fqn,omitempty" yaml:"referenced_fqn,omitempty" xml:"referenced_fqn,omitempty"` // Fully qualified reference
	OnDelete           string         `json:"on_delete,omitempty" yaml:"on_delete,omitempty" xml:"on_delete,omitempty"`
	OnUpdate           string         `json:"on_update,omitempty" yaml:"on_update,omitempty" xml:"on_update,omitempty"`
}

FlatConstraint represents a constraint with full database context and resolved references.

type FlatRelationship 

type FlatRelationship struct {
	DatabaseName     string       `json:"database_name" yaml:"database_name" xml:"database_name"`
	RelationshipName string       `json:"relationship_name" yaml:"relationship_name" xml:"relationship_name"`
	Type             RelationType `json:"type" yaml:"type" xml:"type"`
	FromFQN          string       `json:"from_fqn" yaml:"from_fqn" xml:"from_fqn"` // database.schema.table
	ToFQN            string       `json:"to_fqn" yaml:"to_fqn" xml:"to_fqn"`       // database.schema.table
	FromTable        string       `json:"from_table" yaml:"from_table" xml:"from_table"`
	FromSchema       string       `json:"from_schema" yaml:"from_schema" xml:"from_schema"`
	ToTable          string       `json:"to_table" yaml:"to_table" xml:"to_table"`
	ToSchema         string       `json:"to_schema" yaml:"to_schema" xml:"to_schema"`
	ForeignKey       string       `json:"foreign_key" yaml:"foreign_key" xml:"foreign_key"`
	ThroughTableFQN  string       `json:"through_table_fqn,omitempty" yaml:"through_table_fqn,omitempty" xml:"through_table_fqn,omitempty"`
	Description      string       `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
}

FlatRelationship represents a relationship with full database context and fully qualified table names.

type FlatTable 

type FlatTable struct {
	DatabaseName       string `json:"database_name" yaml:"database_name" xml:"database_name"`
	SchemaName         string `json:"schema_name" yaml:"schema_name" xml:"schema_name"`
	TableName          string `json:"table_name" yaml:"table_name" xml:"table_name"`
	FullyQualifiedName string `json:"fully_qualified_name" yaml:"fully_qualified_name" xml:"fully_qualified_name"` // database.schema.table
	Description        string `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Comment            string `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Tablespace         string `json:"tablespace,omitempty" yaml:"tablespace,omitempty" xml:"tablespace,omitempty"`
	ColumnCount        int    `json:"column_count" yaml:"column_count" xml:"column_count"`
	ConstraintCount    int    `json:"constraint_count" yaml:"constraint_count" xml:"constraint_count"`
	IndexCount         int    `json:"index_count" yaml:"index_count" xml:"index_count"`
}

FlatTable represents a table with full database context and aggregated counts.

type Index 

type Index struct {
	Name        string   `json:"name" yaml:"name" xml:"name"`
	Description string   `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Table       string   `json:"table,omitempty" yaml:"table,omitempty" xml:"table,omitempty"`
	Schema      string   `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
	Columns     []string `json:"columns" yaml:"columns" xml:"columns"`
	Unique      bool     `json:"unique" yaml:"unique" xml:"unique"`
	Type        string   `json:"type" yaml:"type" xml:"type"`                                  // btree, hash, gin, gist, etc.
	Where       string   `json:"where,omitempty" yaml:"where,omitempty" xml:"where,omitempty"` // partial index condition
	Concurrent  bool     `json:"concurrent,omitempty" yaml:"concurrent,omitempty" xml:"concurrent,omitempty"`
	Include     []string `json:"include,omitempty" yaml:"include,omitempty" xml:"include,omitempty"` // INCLUDE columns
	Comment     string   `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Sequence    uint     `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
}

Index represents a database index for optimizing query performance. Indexes can be unique, partial, or include additional columns.

func InitIndex 

func InitIndex(name, table, schema string) *Index

InitIndex initializes a new Index with empty slices

func (*Index) SQLName 

func (d *Index) SQLName() string

SQLName returns the index name in lowercase for SQL compatibility.

type RelationType 

type RelationType string

RelationType represents the type of relationship between database tables. 

const (
	OneToOne   RelationType = "one_to_one"   // One record in table A relates to one record in table B
	OneToMany  RelationType = "one_to_many"  // One record in table A relates to many records in table B
	ManyToMany RelationType = "many_to_many" // Many records in table A relate to many records in table B
)

Supported relationship types.

type Relationship 

type Relationship struct {
	Name          string            `json:"name" yaml:"name" xml:"name"`
	Type          RelationType      `json:"type" yaml:"type" xml:"type"`
	FromTable     string            `json:"from_table" yaml:"from_table" xml:"from_table"`
	FromSchema    string            `json:"from_schema" yaml:"from_schema" xml:"from_schema"`
	FromColumns   []string          `json:"from_columns" yaml:"from_columns" xml:"from_columns"`
	ToTable       string            `json:"to_table" yaml:"to_table" xml:"to_table"`
	ToSchema      string            `json:"to_schema" yaml:"to_schema" xml:"to_schema"`
	ToColumns     []string          `json:"to_columns" yaml:"to_columns" xml:"to_columns"`
	ForeignKey    string            `json:"foreign_key" yaml:"foreign_key" xml:"foreign_key"`
	Properties    map[string]string `json:"properties" yaml:"properties" xml:"-"`
	ThroughTable  string            `json:"through_table,omitempty" yaml:"through_table,omitempty" xml:"through_table,omitempty"` // For many-to-many
	ThroughSchema string            `json:"through_schema,omitempty" yaml:"through_schema,omitempty" xml:"through_schema,omitempty"`
	Description   string            `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Sequence      uint              `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
}

Relationship represents a relationship between two database tables. Relationships can be one-to-one, one-to-many, or many-to-many.

func InitRelation 

func InitRelation(name, schema string) *Relationship

InitRelation initializes a new Relationship with empty slices

func InitRelationship 

func InitRelationship(name string, relType RelationType) *Relationship

InitRelationship initializes a new Relationship with empty maps

func (*Relationship) SQLName 

func (d *Relationship) SQLName() string

SQLName returns the relationship name in lowercase for SQL compatibility.

type SQLNamer 

type SQLNamer interface {
	SQLName() string
}

SQLNamer interface for types that can provide a normalized sql name

type Schema 

type Schema struct {
	Name        string            `json:"name" yaml:"name" xml:"name"`
	Description string            `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Tables      []*Table          `json:"tables" yaml:"tables" xml:"-"`
	Views       []*View           `json:"views,omitempty" yaml:"views,omitempty" xml:"-"`
	Sequences   []*Sequence       `json:"sequences,omitempty" yaml:"sequences,omitempty" xml:"-"`
	Owner       string            `json:"owner" yaml:"owner" xml:"owner"`
	Permissions map[string]string `json:"permissions,omitempty" yaml:"permissions,omitempty" xml:"-"`
	Comment     string            `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Metadata    map[string]any    `json:"metadata,omitempty" yaml:"metadata,omitempty" xml:"-"`
	Scripts     []*Script         `json:"scripts,omitempty" yaml:"scripts,omitempty" xml:"scripts,omitempty"`
	Sequence    uint              `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
	RefDatabase *Database         `json:"-" yaml:"-" xml:"-"` // Excluded to prevent circular references
	Relations   []*Relationship   `json:"relations,omitempty" yaml:"relations,omitempty" xml:"-"`
	Enums       []*Enum           `json:"enums,omitempty" yaml:"enums,omitempty" xml:"enums"`
}

Schema represents a database schema, which is a logical grouping of database objects such as tables, views, sequences, and relationships within a database.

func InitSchema 

func InitSchema(name string) *Schema

InitSchema initializes a new Schema with empty slices and maps

func (*Schema) SQLName 

func (d *Schema) SQLName() string

SQLName returns the schema name in lowercase for SQL compatibility.

func (*Schema) ToSummary 

func (s *Schema) ToSummary() *SchemaSummary

ToSummary converts a Schema to a SchemaSummary with calculated counts.

type SchemaSummary 

type SchemaSummary struct {
	Name             string `json:"name" yaml:"name" xml:"name"`
	Description      string `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Owner            string `json:"owner" yaml:"owner" xml:"owner"`
	TableCount       int    `json:"table_count" yaml:"table_count" xml:"table_count"`
	ScriptCount      int    `json:"script_count" yaml:"script_count" xml:"script_count"`
	TotalColumns     int    `json:"total_columns" yaml:"total_columns" xml:"total_columns"`
	TotalConstraints int    `json:"total_constraints" yaml:"total_constraints" xml:"total_constraints"`
}

SchemaSummary provides a compact overview of a schema with aggregated statistics.

type Script 

type Script struct {
	Name        string   `json:"name" yaml:"name" xml:"name"`
	Description string   `json:"description" yaml:"description" xml:"description"`
	SQL         string   `json:"sql" yaml:"sql" xml:"sql"`
	Rollback    string   `json:"rollback,omitempty" yaml:"rollback,omitempty" xml:"rollback,omitempty"`
	RunAfter    []string `json:"run_after,omitempty" yaml:"run_after,omitempty" xml:"run_after,omitempty"`
	Schema      string   `json:"schema,omitempty" yaml:"schema,omitempty" xml:"schema,omitempty"`
	Version     string   `json:"version,omitempty" yaml:"version,omitempty" xml:"version,omitempty"`
	Priority    int      `json:"priority,omitempty" yaml:"priority,omitempty" xml:"priority,omitempty"`
	Sequence    uint     `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
}

Script represents a database migration or initialization script. Scripts can have dependencies and rollback capabilities.

func InitScript 

func InitScript(name string) *Script

InitScript initializes a new Script with empty slices

func (*Script) SQLName 

func (d *Script) SQLName() string

SQLName returns the script name in lowercase for SQL compatibility.

type Sequence 

type Sequence struct {
	Name          string  `json:"name" yaml:"name" xml:"name"`
	Description   string  `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Schema        string  `json:"schema" yaml:"schema" xml:"schema"`
	StartValue    int64   `json:"start_value" yaml:"start_value" xml:"start_value"`
	MinValue      int64   `json:"min_value,omitempty" yaml:"min_value,omitempty" xml:"min_value,omitempty"`
	MaxValue      int64   `json:"max_value,omitempty" yaml:"max_value,omitempty" xml:"max_value,omitempty"`
	IncrementBy   int64   `json:"increment_by" yaml:"increment_by" xml:"increment_by"`
	CacheSize     int64   `json:"cache_size,omitempty" yaml:"cache_size,omitempty" xml:"cache_size,omitempty"`
	Cycle         bool    `json:"cycle" yaml:"cycle" xml:"cycle"`
	OwnedByTable  string  `json:"owned_by_table,omitempty" yaml:"owned_by_table,omitempty" xml:"owned_by_table,omitempty"`
	OwnedByColumn string  `json:"owned_by_column,omitempty" yaml:"owned_by_column,omitempty" xml:"owned_by_column,omitempty"`
	Comment       string  `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Sequence      uint    `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
	RefSchema     *Schema `json:"-" yaml:"-" xml:"-"` // Excluded to prevent circular references
}

Sequence represents a database sequence (auto-increment generator)

func InitSequence 

func InitSequence(name, schema string) *Sequence

InitSequence initializes a new Sequence with default values

func (*Sequence) SQLName 

func (d *Sequence) SQLName() string

SQLName returns the sequence name in lowercase for SQL compatibility.

type Table 

type Table struct {
	Name          string                   `json:"name" yaml:"name" xml:"name"`
	Description   string                   `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Schema        string                   `json:"schema" yaml:"schema" xml:"schema"`
	Columns       map[string]*Column       `json:"columns" yaml:"columns" xml:"-"`
	Constraints   map[string]*Constraint   `json:"constraints" yaml:"constraints" xml:"-"`
	Indexes       map[string]*Index        `json:"indexes,omitempty" yaml:"indexes,omitempty" xml:"-"`
	Relationships map[string]*Relationship `json:"relationships,omitempty" yaml:"relationships,omitempty" xml:"-"`
	Comment       string                   `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Tablespace    string                   `json:"tablespace,omitempty" yaml:"tablespace,omitempty" xml:"tablespace,omitempty"`
	Metadata      map[string]any           `json:"metadata,omitempty" yaml:"metadata,omitempty" xml:"-"`
	Sequence      uint                     `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
	RefSchema     *Schema                  `json:"-" yaml:"-" xml:"-"` // Excluded to prevent circular references
}

Table represents a database table with its columns, constraints, indexes, and relationships. Tables are the primary data storage structures in a database.

func InitTable 

func InitTable(name, schema string) *Table

InitTable initializes a new Table with empty maps

func (Table) GetForeignKeys 

func (m Table) GetForeignKeys() []*Constraint

GetForeignKeys returns all foreign key constraints for the table.

func (Table) GetPrimaryKey 

func (m Table) GetPrimaryKey() *Column

GetPrimaryKey returns the primary key column for the table, or nil if none exists.

func (*Table) SQLName 

func (d *Table) SQLName() string

SQLName returns the table name in lowercase for SQL compatibility.

func (*Table) ToSummary 

func (t *Table) ToSummary() *TableSummary

ToSummary converts a Table to a TableSummary with calculated counts.

type TableSummary 

type TableSummary struct {
	Name              string `json:"name" yaml:"name" xml:"name"`
	Schema            string `json:"schema" yaml:"schema" xml:"schema"`
	Description       string `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	ColumnCount       int    `json:"column_count" yaml:"column_count" xml:"column_count"`
	ConstraintCount   int    `json:"constraint_count" yaml:"constraint_count" xml:"constraint_count"`
	IndexCount        int    `json:"index_count" yaml:"index_count" xml:"index_count"`
	RelationshipCount int    `json:"relationship_count" yaml:"relationship_count" xml:"relationship_count"`
	HasPrimaryKey     bool   `json:"has_primary_key" yaml:"has_primary_key" xml:"has_primary_key"`
	ForeignKeyCount   int    `json:"foreign_key_count" yaml:"foreign_key_count" xml:"foreign_key_count"`
}

TableSummary provides a compact overview of a table with aggregated statistics.

type View 

type View struct {
	Name        string             `json:"name" yaml:"name" xml:"name"`
	Description string             `json:"description,omitempty" yaml:"description,omitempty" xml:"description,omitempty"`
	Schema      string             `json:"schema" yaml:"schema" xml:"schema"`
	Definition  string             `json:"definition" yaml:"definition" xml:"definition"` // SQL definition
	Columns     map[string]*Column `json:"columns" yaml:"columns" xml:"-"`
	Comment     string             `json:"comment,omitempty" yaml:"comment,omitempty" xml:"comment,omitempty"`
	Metadata    map[string]any     `json:"metadata,omitempty" yaml:"metadata,omitempty" xml:"-"`
	Sequence    uint               `json:"sequence,omitempty" yaml:"sequence,omitempty" xml:"sequence,omitempty"`
	RefSchema   *Schema            `json:"-" yaml:"-" xml:"-"` // Excluded to prevent circular references
}

View represents a database view (read-only)

func InitView 

func InitView(name, schema string) *View

InitView initializes a new View with empty maps

func (*View) SQLName 

func (d *View) SQLName() string

SQLName returns the view name in lowercase for SQL compatibility.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.