diff options
Diffstat (limited to 'vendor/github.com/uptrace/bun/migrate')
9 files changed, 167 insertions, 68 deletions
diff --git a/vendor/github.com/uptrace/bun/migrate/auto.go b/vendor/github.com/uptrace/bun/migrate/auto.go index 8656902ca..51868d50d 100644 --- a/vendor/github.com/uptrace/bun/migrate/auto.go +++ b/vendor/github.com/uptrace/bun/migrate/auto.go @@ -17,17 +17,21 @@ import ( type AutoMigratorOption func(m *AutoMigrator) -// WithModel adds a bun.Model to the scope of migrations. +// WithModel adds a bun.Model to the migration scope. func WithModel(models ...interface{}) AutoMigratorOption { return func(m *AutoMigrator) { m.includeModels = append(m.includeModels, models...) } } -// WithExcludeTable tells the AutoMigrator to ignore a table in the database. +// WithExcludeTable tells AutoMigrator to exclude database tables from the migration scope. // This prevents AutoMigrator from dropping tables which may exist in the schema // but which are not used by the application. // +// Expressions may make use of the wildcards supported by the SQL LIKE operator: +// - % as a wildcard +// - _ as a single character +// // Do not exclude tables included via WithModel, as BunModelInspector ignores this setting. func WithExcludeTable(tables ...string) AutoMigratorOption { return func(m *AutoMigrator) { @@ -35,7 +39,17 @@ func WithExcludeTable(tables ...string) AutoMigratorOption { } } -// WithSchemaName changes the default database schema to migrate objects in. +// WithExcludeForeignKeys tells AutoMigrator to exclude a foreign key constaint +// from the migration scope. This prevents AutoMigrator from dropping foreign keys +// that are defined manually via CreateTableQuery.ForeignKey(). +func WithExcludeForeignKeys(fks ...sqlschema.ForeignKey) AutoMigratorOption { + return func(m *AutoMigrator) { + m.excludeForeignKeys = append(m.excludeForeignKeys, fks...) + } +} + +// WithSchemaName sets the database schema to migrate objects in. +// By default, dialects' default schema is used. func WithSchemaName(schemaName string) AutoMigratorOption { return func(m *AutoMigrator) { m.schemaName = schemaName @@ -82,7 +96,7 @@ func WithMigrationsDirectoryAuto(directory string) AutoMigratorOption { // database schema automatically. // // Usage: -// 1. Generate migrations and apply them au once with AutoMigrator.Migrate(). +// 1. Generate migrations and apply them at once with AutoMigrator.Migrate(). // 2. Create up- and down-SQL migration files and apply migrations using Migrator.Migrate(). // // While both methods produce complete, reversible migrations (with entries in the database @@ -124,8 +138,8 @@ type AutoMigrator struct { // includeModels define the migration scope. includeModels []interface{} - // excludeTables are excluded from database inspection. - excludeTables []string + excludeTables []string // excludeTables are excluded from database inspection. + excludeForeignKeys []sqlschema.ForeignKey // excludeForeignKeys are excluded from database inspection. // diffOpts are passed to detector constructor. diffOpts []diffOption @@ -150,7 +164,11 @@ func NewAutoMigrator(db *bun.DB, opts ...AutoMigratorOption) (*AutoMigrator, err } am.excludeTables = append(am.excludeTables, am.table, am.locksTable) - dbInspector, err := sqlschema.NewInspector(db, sqlschema.WithSchemaName(am.schemaName), sqlschema.WithExcludeTables(am.excludeTables...)) + dbInspector, err := sqlschema.NewInspector(db, + sqlschema.WithSchemaName(am.schemaName), + sqlschema.WithExcludeTables(am.excludeTables...), + sqlschema.WithExcludeForeignKeys(am.excludeForeignKeys...), + ) if err != nil { return nil, err } @@ -252,12 +270,12 @@ func (am *AutoMigrator) createSQLMigrations(ctx context.Context, transactional b migrations := NewMigrations(am.migrationsOpts...) migrations.Add(Migration{ Name: name, - Up: changes.Up(am.dbMigrator), - Down: changes.Down(am.dbMigrator), + Up: wrapMigrationFunc(changes.Up(am.dbMigrator)), + Down: wrapMigrationFunc(changes.Down(am.dbMigrator)), Comment: "Changes detected by bun.AutoMigrator", }) - // Append .tx.up.sql or .up.sql to migration name, dependin if it should be transactional. + // Append .tx.up.sql or .up.sql to migration name, depending if it should be transactional. fname := func(direction string) string { return name + map[bool]string{true: ".tx.", false: "."}[transactional] + direction + ".sql" } @@ -336,7 +354,7 @@ func (c *changeset) apply(ctx context.Context, db *bun.DB, m sqlschema.Migrator) } for _, op := range c.operations { - if _, isComment := op.(*comment); isComment { + if _, skip := op.(*Unimplemented); skip { continue } @@ -359,17 +377,22 @@ func (c *changeset) WriteTo(w io.Writer, m sqlschema.Migrator) error { b := internal.MakeQueryBytes() for _, op := range c.operations { - if c, isComment := op.(*comment); isComment { + if comment, isComment := op.(*Unimplemented); isComment { b = append(b, "/*\n"...) - b = append(b, *c...) + b = append(b, *comment...) b = append(b, "\n*/"...) continue } - b, err = m.AppendSQL(b, op) + // Append each query separately, merge later. + // Dialects assume that the []byte only holds + // the contents of a single query and may be misled. + queryBytes := internal.MakeQueryBytes() + queryBytes, err = m.AppendSQL(queryBytes, op) if err != nil { return fmt.Errorf("write changeset: %w", err) } + b = append(b, queryBytes...) b = append(b, ";\n"...) } if _, err := w.Write(b); err != nil { @@ -409,7 +432,7 @@ func (c *changeset) ResolveDependencies() error { } // visit iterates over c.operations until it finds all operations that depend on the current one - // or runs into cirtular dependency, in which case it will return an error. + // or runs into circular dependency, in which case it will return an error. visit = func(op Operation) error { switch status[op] { case visited: diff --git a/vendor/github.com/uptrace/bun/migrate/diff.go b/vendor/github.com/uptrace/bun/migrate/diff.go index e05d54b7d..d12c11cb5 100644 --- a/vendor/github.com/uptrace/bun/migrate/diff.go +++ b/vendor/github.com/uptrace/bun/migrate/diff.go @@ -1,6 +1,7 @@ package migrate import ( + "github.com/uptrace/bun/internal/ordered" "github.com/uptrace/bun/migrate/sqlschema" ) @@ -22,8 +23,8 @@ func diff(got, want sqlschema.Database, opts ...diffOption) *changeset { } func (d *detector) detectChanges() *changeset { - currentTables := d.current.GetTables() - targetTables := d.target.GetTables() + currentTables := toOrderedMap(d.current.GetTables()) + targetTables := toOrderedMap(d.target.GetTables()) RenameCreate: for _, wantPair := range targetTables.Pairs() { @@ -99,10 +100,19 @@ RenameCreate: return &d.changes } -// detechColumnChanges finds renamed columns and, if checkType == true, columns with changed type. +// toOrderedMap transforms a slice of objects to an ordered map, using return of GetName() as key. +func toOrderedMap[V interface{ GetName() string }](named []V) *ordered.Map[string, V] { + m := ordered.NewMap[string, V]() + for _, v := range named { + m.Store(v.GetName(), v) + } + return m +} + +// detectColumnChanges finds renamed columns and, if checkType == true, columns with changed type. func (d *detector) detectColumnChanges(current, target sqlschema.Table, checkType bool) { - currentColumns := current.GetColumns() - targetColumns := target.GetColumns() + currentColumns := toOrderedMap(current.GetColumns()) + targetColumns := toOrderedMap(target.GetColumns()) ChangeRename: for _, tPair := range targetColumns.Pairs() { @@ -265,7 +275,7 @@ type detector struct { // cmpType determines column type equivalence. // Default is direct comparison with '==' operator, which is inaccurate // due to the existence of dialect-specific type aliases. The caller - // should pass a concrete InspectorDialect.EquuivalentType for robust comparison. + // should pass a concrete InspectorDialect.EquivalentType for robust comparison. cmpType CompareTypeFunc } @@ -283,7 +293,7 @@ func (d detector) equalColumns(col1, col2 sqlschema.Column) bool { } func (d detector) makeTargetColDef(current, target sqlschema.Column) sqlschema.Column { - // Avoid unneccessary type-change migrations if the types are equivalent. + // Avoid unnecessary type-change migrations if the types are equivalent. if d.cmpType(current, target) { target = &sqlschema.BaseColumn{ Name: target.GetName(), @@ -311,8 +321,7 @@ func equalSignatures(t1, t2 sqlschema.Table, eq CompareTypeFunc) bool { // signature is a set of column definitions, which allows "relation/name-agnostic" comparison between them; // meaning that two columns are considered equal if their types are the same. type signature struct { - - // underlying stores the number of occurences for each unique column type. + // underlying stores the number of occurrences for each unique column type. // It helps to account for the fact that a table might have multiple columns that have the same type. underlying map[sqlschema.BaseColumn]int @@ -330,7 +339,7 @@ func newSignature(t sqlschema.Table, eq CompareTypeFunc) signature { // scan iterates over table's field and counts occurrences of each unique column definition. func (s *signature) scan(t sqlschema.Table) { - for _, icol := range t.GetColumns().Values() { + for _, icol := range t.GetColumns() { scanCol := icol.(*sqlschema.BaseColumn) // This is slightly more expensive than if the columns could be compared directly // and we always did s.underlying[col]++, but we get type-equivalence in return. @@ -368,7 +377,7 @@ func (s *signature) Equals(other signature) bool { } // refMap is a utility for tracking superficial changes in foreign keys, -// which do not require any modificiation in the database. +// which do not require any modification in the database. // Modern SQL dialects automatically updated foreign key constraints whenever // a column or a table is renamed. Detector can use refMap to ignore any // differences in foreign keys which were caused by renamed column/table. diff --git a/vendor/github.com/uptrace/bun/migrate/migration.go b/vendor/github.com/uptrace/bun/migrate/migration.go index 3f4076d2b..4d60a5858 100644 --- a/vendor/github.com/uptrace/bun/migrate/migration.go +++ b/vendor/github.com/uptrace/bun/migrate/migration.go @@ -9,6 +9,7 @@ import ( "io/fs" "sort" "strings" + "text/template" "time" "github.com/uptrace/bun" @@ -23,8 +24,8 @@ type Migration struct { GroupID int64 MigratedAt time.Time `bun:",notnull,nullzero,default:current_timestamp"` - Up MigrationFunc `bun:"-"` - Down MigrationFunc `bun:"-"` + Up internalMigrationFunc `bun:"-"` + Down internalMigrationFunc `bun:"-"` } func (m Migration) String() string { @@ -35,23 +36,57 @@ func (m Migration) IsApplied() bool { return m.ID > 0 } +type internalMigrationFunc func(ctx context.Context, db *bun.DB, templateData any) error + type MigrationFunc func(ctx context.Context, db *bun.DB) error -func NewSQLMigrationFunc(fsys fs.FS, name string) MigrationFunc { - return func(ctx context.Context, db *bun.DB) error { +func NewSQLMigrationFunc(fsys fs.FS, name string) internalMigrationFunc { + return func(ctx context.Context, db *bun.DB, templateData any) error { f, err := fsys.Open(name) if err != nil { return err } isTx := strings.HasSuffix(name, ".tx.up.sql") || strings.HasSuffix(name, ".tx.down.sql") - return Exec(ctx, db, f, isTx) + return Exec(ctx, db, f, templateData, isTx) + } +} + +func wrapMigrationFunc(fn MigrationFunc) internalMigrationFunc { + return func(ctx context.Context, db *bun.DB, templateData any) error { + return fn(ctx, db) + } +} + +func renderTemplate(contents []byte, templateData any) (*bytes.Buffer, error) { + tmpl, err := template.New("migration").Parse(string(contents)) + if err != nil { + return nil, fmt.Errorf("failed to parse template: %w", err) + } + + var rendered bytes.Buffer + if err := tmpl.Execute(&rendered, templateData); err != nil { + return nil, fmt.Errorf("failed to execute template: %w", err) } + + return &rendered, nil } // Exec reads and executes the SQL migration in the f. -func Exec(ctx context.Context, db *bun.DB, f io.Reader, isTx bool) error { - scanner := bufio.NewScanner(f) +func Exec(ctx context.Context, db *bun.DB, f io.Reader, templateData any, isTx bool) error { + contents, err := io.ReadAll(f) + if err != nil { + return err + } + var reader io.Reader = bytes.NewReader(contents) + if templateData != nil { + buf, err := renderTemplate(contents, templateData) + if err != nil { + return err + } + reader = buf + } + scanner := bufio.NewScanner(reader) var queries []string var query []byte diff --git a/vendor/github.com/uptrace/bun/migrate/migrations.go b/vendor/github.com/uptrace/bun/migrate/migrations.go index 1a7ea5668..a22e615cb 100644 --- a/vendor/github.com/uptrace/bun/migrate/migrations.go +++ b/vendor/github.com/uptrace/bun/migrate/migrations.go @@ -58,8 +58,8 @@ func (m *Migrations) Register(up, down MigrationFunc) error { m.Add(Migration{ Name: name, Comment: comment, - Up: up, - Down: down, + Up: wrapMigrationFunc(up), + Down: wrapMigrationFunc(down), }) return nil diff --git a/vendor/github.com/uptrace/bun/migrate/migrator.go b/vendor/github.com/uptrace/bun/migrate/migrator.go index d5a72aec0..a325c3993 100644 --- a/vendor/github.com/uptrace/bun/migrate/migrator.go +++ b/vendor/github.com/uptrace/bun/migrate/migrator.go @@ -41,6 +41,12 @@ func WithMarkAppliedOnSuccess(enabled bool) MigratorOption { } } +func WithTemplateData(data any) MigratorOption { + return func(m *Migrator) { + m.templateData = data + } +} + type Migrator struct { db *bun.DB migrations *Migrations @@ -50,6 +56,8 @@ type Migrator struct { table string locksTable string markAppliedOnSuccess bool + + templateData any } func NewMigrator(db *bun.DB, migrations *Migrations, opts ...MigratorOption) *Migrator { @@ -168,7 +176,7 @@ func (m *Migrator) Migrate(ctx context.Context, opts ...MigrationOption) (*Migra group.Migrations = migrations[:i+1] if !cfg.nop && migration.Up != nil { - if err := migration.Up(ctx, m.db); err != nil { + if err := migration.Up(ctx, m.db, m.templateData); err != nil { return group, err } } @@ -207,7 +215,7 @@ func (m *Migrator) Rollback(ctx context.Context, opts ...MigrationOption) (*Migr } if !cfg.nop && migration.Down != nil { - if err := migration.Down(ctx, m.db); err != nil { + if err := migration.Down(ctx, m.db, m.templateData); err != nil { return lastGroup, err } } diff --git a/vendor/github.com/uptrace/bun/migrate/operations.go b/vendor/github.com/uptrace/bun/migrate/operations.go index 7b749c5a0..cede23d73 100644 --- a/vendor/github.com/uptrace/bun/migrate/operations.go +++ b/vendor/github.com/uptrace/bun/migrate/operations.go @@ -17,7 +17,7 @@ import ( // about the applied change. // // Some operations might be irreversible due to technical limitations. Returning -// a *comment from GetReverse() will add an explanatory note to the generate migation file. +// a *comment from GetReverse() will add an explanatory note to the generate migration file. // // To declare dependency on another Operation, operations should implement // { DependsOn(Operation) bool } interface, which Changeset will use to resolve dependencies. @@ -56,7 +56,7 @@ func (op *DropTableOp) DependsOn(another Operation) bool { // GetReverse for a DropTable returns a no-op migration. Logically, CreateTable is the reverse, // but DropTable does not have the table's definition to create one. func (op *DropTableOp) GetReverse() Operation { - c := comment(fmt.Sprintf("WARNING: \"DROP TABLE %s\" cannot be reversed automatically because table definition is not available", op.TableName)) + c := Unimplemented(fmt.Sprintf("WARNING: \"DROP TABLE %s\" cannot be reversed automatically because table definition is not available", op.TableName)) return &c } @@ -224,7 +224,6 @@ func (op *AddUniqueConstraintOp) DependsOn(another Operation) bool { default: return false } - } // DropUniqueConstraintOp drops a UNIQUE constraint. @@ -326,15 +325,15 @@ func (op *ChangePrimaryKeyOp) GetReverse() Operation { } } -// comment denotes an Operation that cannot be executed. +// Unimplemented denotes an Operation that cannot be executed. // // Operations, which cannot be reversed due to current technical limitations, -// may return &comment with a helpful message from their GetReverse() method. +// may have their GetReverse() return &Unimplemented with a helpful message. // -// Chnagelog should skip it when applying operations or output as log message, -// and write it as an SQL comment when creating migration files. -type comment string +// When applying operations, changelog should skip it or output as a log message, +// and write it as an SQL Unimplemented when creating migration files. +type Unimplemented string -var _ Operation = (*comment)(nil) +var _ Operation = (*Unimplemented)(nil) -func (c *comment) GetReverse() Operation { return c } +func (reason *Unimplemented) GetReverse() Operation { return reason } diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go index eb7476c54..3741f0c5d 100644 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go +++ b/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go @@ -4,12 +4,11 @@ import ( "slices" "strings" - "github.com/uptrace/bun/internal/ordered" "github.com/uptrace/bun/schema" ) type Database interface { - GetTables() *ordered.Map[string, Table] + GetTables() []Table GetForeignKeys() map[ForeignKey]string } @@ -20,11 +19,11 @@ var _ Database = (*BaseDatabase)(nil) // Dialects and only dialects can use it to implement the Database interface. // Other packages must use the Database interface. type BaseDatabase struct { - Tables *ordered.Map[string, Table] + Tables []Table ForeignKeys map[ForeignKey]string } -func (ds BaseDatabase) GetTables() *ordered.Map[string, Table] { +func (ds BaseDatabase) GetTables() []Table { return ds.Tables } diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go index 19d1dc469..d7333e8a9 100644 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go +++ b/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go @@ -7,7 +7,6 @@ import ( "strings" "github.com/uptrace/bun" - "github.com/uptrace/bun/internal/ordered" "github.com/uptrace/bun/schema" ) @@ -30,12 +29,23 @@ type InspectorDialect interface { // InspectorConfig controls the scope of migration by limiting the objects Inspector should return. // Inspectors SHOULD use the configuration directly instead of copying it, or MAY choose to embed it, // to make sure options are always applied correctly. +// +// ExcludeTables and ExcludeForeignKeys are intended for database inspectors, +// to compensate for the fact that model structs may not wholly reflect the +// state of the database schema. +// Database inspectors MUST respect these exclusions to prevent relations +// from being dropped unintentionally. type InspectorConfig struct { // SchemaName limits inspection to tables in a particular schema. SchemaName string - // ExcludeTables from inspection. + // ExcludeTables from inspection. Patterns MAY make use of wildcards + // like % and _ and dialects MUST acknowledge that by using them + // with the SQL LIKE operator. ExcludeTables []string + + // ExcludeForeignKeys from inspection. + ExcludeForeignKeys map[ForeignKey]string } // Inspector reads schema state. @@ -49,13 +59,26 @@ func WithSchemaName(schemaName string) InspectorOption { } } -// WithExcludeTables works in append-only mode, i.e. tables cannot be re-included. +// WithExcludeTables forces inspector to exclude tables from the reported schema state. +// It works in append-only mode, i.e. tables cannot be re-included. +// +// Patterns MAY make use of % and _ wildcards, as if writing a LIKE clause in SQL. func WithExcludeTables(tables ...string) InspectorOption { return func(cfg *InspectorConfig) { cfg.ExcludeTables = append(cfg.ExcludeTables, tables...) } } +// WithExcludeForeignKeys forces inspector to exclude foreign keys +// from the reported schema state. +func WithExcludeForeignKeys(fks ...ForeignKey) InspectorOption { + return func(cfg *InspectorConfig) { + for _, fk := range fks { + cfg.ExcludeForeignKeys[fk] = "" + } + } +} + // NewInspector creates a new database inspector, if the dialect supports it. func NewInspector(db *bun.DB, options ...InspectorOption) (Inspector, error) { dialect, ok := (db.Dialect()).(InspectorDialect) @@ -78,6 +101,9 @@ func NewBunModelInspector(tables *schema.Tables, options ...InspectorOption) *Bu type InspectorOption func(*InspectorConfig) func ApplyInspectorOptions(cfg *InspectorConfig, options ...InspectorOption) { + if cfg.ExcludeForeignKeys == nil { + cfg.ExcludeForeignKeys = make(map[ForeignKey]string) + } for _, opt := range options { opt(cfg) } @@ -90,6 +116,10 @@ type inspector struct { // BunModelInspector creates the current project state from the passed bun.Models. // Do not recycle BunModelInspector for different sets of models, as older models will not be de-registerred before the next run. +// +// BunModelInspector does not know which the database's dialect, so it does not +// assume any default schema name. Always specify the target schema name via +// WithSchemaName option to receive meaningful results. type BunModelInspector struct { InspectorConfig tables *schema.Tables @@ -102,21 +132,21 @@ func (bmi *BunModelInspector) Inspect(ctx context.Context) (Database, error) { BaseDatabase: BaseDatabase{ ForeignKeys: make(map[ForeignKey]string), }, - Tables: ordered.NewMap[string, Table](), } for _, t := range bmi.tables.All() { if t.Schema != bmi.SchemaName { continue } - columns := ordered.NewMap[string, Column]() + var columns []Column for _, f := range t.Fields { sqlType, length, err := parseLen(f.CreateTableSQLType) if err != nil { return nil, fmt.Errorf("parse length in %q: %w", f.CreateTableSQLType, err) } - columns.Store(f.Name, &BaseColumn{ + + columns = append(columns, &BaseColumn{ Name: f.Name, SQLType: strings.ToLower(sqlType), // TODO(dyma): maybe this is not necessary after Column.Eq() VarcharLen: length, @@ -162,7 +192,7 @@ func (bmi *BunModelInspector) Inspect(ctx context.Context) (Database, error) { // produces // schema.Table{ Schema: "favourite", Name: "favourite.books" } tableName := strings.TrimPrefix(t.Name, t.Schema+".") - state.Tables.Store(tableName, &BunTable{ + state.Tables = append(state.Tables, &BunTable{ BaseTable: BaseTable{ Schema: t.Schema, Name: tableName, @@ -212,7 +242,7 @@ func parseLen(typ string) (string, int, error) { } // exprOrLiteral converts string to lowercase, if it does not contain a string literal 'lit' -// and trims the surrounding '' otherwise. +// and trims the surrounding ” otherwise. // Use it to ensure that user-defined default values in the models are always comparable // to those returned by the database inspector, regardless of the case convention in individual drivers. func exprOrLiteral(s string) string { @@ -226,10 +256,10 @@ func exprOrLiteral(s string) string { type BunModelSchema struct { BaseDatabase - Tables *ordered.Map[string, Table] + Tables []Table } -func (ms BunModelSchema) GetTables() *ordered.Map[string, Table] { +func (ms BunModelSchema) GetTables() []Table { return ms.Tables } diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go index ec9b77f69..5e48d9adf 100644 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go +++ b/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go @@ -1,13 +1,9 @@ package sqlschema -import ( - "github.com/uptrace/bun/internal/ordered" -) - type Table interface { GetSchema() string GetName() string - GetColumns() *ordered.Map[string, Column] + GetColumns() []Column GetPrimaryKey() *PrimaryKey GetUniqueConstraints() []Unique } @@ -23,7 +19,7 @@ type BaseTable struct { Name string // ColumnDefinitions map each column name to the column definition. - Columns *ordered.Map[string, Column] + Columns []Column // PrimaryKey holds the primary key definition. // A nil value means that no primary key is defined for the table. @@ -47,7 +43,7 @@ func (td *BaseTable) GetName() string { return td.Name } -func (td *BaseTable) GetColumns() *ordered.Map[string, Column] { +func (td *BaseTable) GetColumns() []Column { return td.Columns } |