Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(schema/pg): skip column-dependent DDL for tables synced without columns (#20582)

rebeliceae8ad9f917c2
diff --git a/backend/plugin/schema/pg/get_database_definition.go b/backend/plugin/schema/pg/get_database_definition.go
index c2f969fe37..cd87b7e734 100644
--- a/backend/plugin/schema/pg/get_database_definition.go
+++ b/backend/plugin/schema/pg/get_database_definition.go
@@ -284,78 +284,23 @@ func GetDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *storepb.Da
// Construct triggers.
for _, schema := range metadata.Schemas {
- for _, table := range schema.Tables {
- for _, trigger := range table.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, table.Name, trigger); err != nil {
- return "", err
- }
- }
- }
-
- for _, view := range schema.Views {
- for _, trigger := range view.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, view.Name, trigger); err != nil {
- return "", err
- }
- }
- }
-
- for _, materializedView := range schema.MaterializedViews {
- for _, trigger := range materializedView.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, materializedView.Name, trigger); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaTriggers(&buf, schema); err != nil {
+ return "", err
}
}
// Construct rules.
for _, schema := range metadata.Schemas {
- for _, table := range schema.Tables {
- if len(table.Rules) > 0 {
- if err := writeRules(&buf, schema.Name, table.Name, table.Rules); err != nil {
- return "", err
- }
- }
- }
-
- for _, view := range schema.Views {
- // Rules for views are already written in writeView
- // Only write non-SELECT rules here (they are not part of the view definition)
- var nonSelectRules []*storepb.RuleMetadata
- for _, rule := range view.Rules {
- if rule.Event != "SELECT" {
- nonSelectRules = append(nonSelectRules, rule)
- }
- }
- if len(nonSelectRules) > 0 {
- if err := writeRules(&buf, schema.Name, view.Name, nonSelectRules); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaRules(&buf, schema); err != nil {
+ return "", err
}
}
// Construct foreign keys.
+ tablesMissingColumns := collectTables(metadata.Schemas, tableMissingColumnMetadata)
for _, schema := range metadata.Schemas {
- for _, table := range schema.Tables {
- if table.SkipDump {
- continue
- }
- for _, fk := range table.ForeignKeys {
- if err := writeForeignKey(&buf, schema.Name, table.Name, fk); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaForeignKeys(&buf, schema, tablesMissingColumns); err != nil {
+ return "", err
}
}
@@ -560,73 +505,18 @@ func GetSchemaDefinition(schema *storepb.SchemaMetadata) (string, error) {
}
// Construct triggers.
- for _, table := range schema.Tables {
- for _, trigger := range table.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, table.Name, trigger); err != nil {
- return "", err
- }
- }
- }
-
- for _, view := range schema.Views {
- for _, trigger := range view.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, view.Name, trigger); err != nil {
- return "", err
- }
- }
- }
-
- for _, materializedView := range schema.MaterializedViews {
- for _, trigger := range materializedView.Triggers {
- if trigger.SkipDump {
- continue
- }
- if err := writeTrigger(&buf, schema.Name, materializedView.Name, trigger); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaTriggers(&buf, schema); err != nil {
+ return "", err
}
// Construct rules.
- for _, table := range schema.Tables {
- if len(table.Rules) > 0 {
- if err := writeRules(&buf, schema.Name, table.Name, table.Rules); err != nil {
- return "", err
- }
- }
- }
-
- for _, view := range schema.Views {
- // Only write non-SELECT rules here (SELECT rules are part of the view definition)
- var nonSelectRules []*storepb.RuleMetadata
- for _, rule := range view.Rules {
- if rule.Event != "SELECT" {
- nonSelectRules = append(nonSelectRules, rule)
- }
- }
- if len(nonSelectRules) > 0 {
- if err := writeRules(&buf, schema.Name, view.Name, nonSelectRules); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaRules(&buf, schema); err != nil {
+ return "", err
}
// Construct foreign keys.
- for _, table := range schema.Tables {
- if table.SkipDump {
- continue
- }
- for _, fk := range table.ForeignKeys {
- if err := writeForeignKey(&buf, schema.Name, table.Name, fk); err != nil {
- return "", err
- }
- }
+ if err := writeSchemaForeignKeys(&buf, schema, collectTables([]*storepb.SchemaMetadata{schema}, tableMissingColumnMetadata)); err != nil {
+ return "", err
}
return buf.String(), nil
@@ -637,6 +527,11 @@ func GetTableDefinition(schema string, table *storepb.TableMetadata, sequences [
if err := writeTable(&buf, schema, table, sequences); err != nil {
return "", err
}
+ // Skip triggers, rules, and foreign keys for a table without column
+ // metadata; their definitions can reference the missing columns.
+ if tableMissingColumnMetadata(table) {
+ return buf.String(), nil
+ }
// Construct triggers.
for _, trigger := range table.Triggers {
if trigger.SkipDump {
@@ -1681,7 +1576,156 @@ func splitSequencesByIdentityOrNot(table *storepb.TableMetadata, sequences []*st
return generationType, identitySequences, nonIdentitySequences
}
+// tableMissingColumnMetadata reports whether a synced table's column list
+// was filtered away. information_schema.columns is privilege-filtered, so a
+// sync user without column privileges on a table sees zero columns while the
+// pg_catalog-based queries still return the table's constraints, indexes,
+// triggers, and rules. DDL referencing the missing columns would make the
+// dump non-replayable, so writers skip column-dependent statements for such
+// tables.
+//
+// A genuine zero-column table (CREATE TABLE t ()) is legal in PostgreSQL and
+// may carry column-independent objects such as CHECK (1 = 1), but it cannot
+// carry primary keys, unique constraints, foreign keys, or a partition key
+// (PostgreSQL rejects constant partition-key expressions); indexes on it are
+// limited to constant-expression corner cases. Treat zero columns as missing
+// metadata only when such objects are present, so genuine zero-column tables
+// keep their objects.
+func tableMissingColumnMetadata(table *storepb.TableMetadata) bool {
+ return len(table.Columns) == 0 &&
+ (len(table.Indexes) > 0 || len(table.ForeignKeys) > 0 || len(table.Partitions) > 0)
+}
+
+// tableHasNoColumns reports an empty synced column list, whether genuinely
+// zero-column or privilege-filtered. A sequence cannot be owned by a column
+// of such a table, so ALTER SEQUENCE ... OWNED BY is skipped either way.
+func tableHasNoColumns(table *storepb.TableMetadata) bool {
+ return len(table.Columns) == 0
+}
+
+// collectTables returns the tables matching include, keyed by
+// getObjectID(schema, table).
+func collectTables(schemas []*storepb.SchemaMetadata, include func(*storepb.TableMetadata) bool) map[string]bool {
+ set := make(map[string]bool)
+ for _, schema := range schemas {
+ for _, table := range schema.Tables {
+ if include(table) {
+ set[getObjectID(schema.Name, table.Name)] = true
+ }
+ }
+ }
+ return set
+}
+
+// writeSchemaTriggers writes the triggers of every table, view, and
+// materialized view in the schema. Triggers on tables without column
+// metadata are skipped; their definitions (UPDATE OF, WHEN clauses) can
+// reference the missing columns.
+func writeSchemaTriggers(out io.Writer, schema *storepb.SchemaMetadata) error {
+ for _, table := range schema.Tables {
+ if tableMissingColumnMetadata(table) {
+ continue
+ }
+ for _, trigger := range table.Triggers {
+ if trigger.SkipDump {
+ continue
+ }
+ if err := writeTrigger(out, schema.Name, table.Name, trigger); err != nil {
+ return err
+ }
+ }
+ }
+
+ for _, view := range schema.Views {
+ for _, trigger := range view.Triggers {
+ if trigger.SkipDump {
+ continue
+ }
+ if err := writeTrigger(out, schema.Name, view.Name, trigger); err != nil {
+ return err
+ }
+ }
+ }
+
+ for _, materializedView := range schema.MaterializedViews {
+ for _, trigger := range materializedView.Triggers {
+ if trigger.SkipDump {
+ continue
+ }
+ if err := writeTrigger(out, schema.Name, materializedView.Name, trigger); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// writeSchemaRules writes the rules of every table and the non-SELECT rules
+// of every view in the schema (SELECT rules are part of the view
+// definition). Rules on tables without column metadata are skipped; their
+// definitions can reference the missing columns.
+func writeSchemaRules(out io.Writer, schema *storepb.SchemaMetadata) error {
+ for _, table := range schema.Tables {
+ if len(table.Rules) > 0 && !tableMissingColumnMetadata(table) {
+ if err := writeRules(out, schema.Name, table.Name, table.Rules); err != nil {
+ return err
+ }
+ }
+ }
+
+ for _, view := range schema.Views {
+ var nonSelectRules []*storepb.RuleMetadata
+ for _, rule := range view.Rules {
+ if rule.Event != "SELECT" {
+ nonSelectRules = append(nonSelectRules, rule)
+ }
+ }
+ if len(nonSelectRules) > 0 {
+ if err := writeRules(out, schema.Name, view.Name, nonSelectRules); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// writeSchemaForeignKeys writes the foreign keys of every table in the
+// schema, skipping foreign keys touching a table without column metadata on
+// either side; they would reference columns absent from the dump.
+func writeSchemaForeignKeys(out io.Writer, schema *storepb.SchemaMetadata, tablesMissingColumns map[string]bool) error {
+ for _, table := range schema.Tables {
+ if table.SkipDump || tablesMissingColumns[getObjectID(schema.Name, table.Name)] {
+ continue
+ }
+ for _, fk := range table.ForeignKeys {
+ if tablesMissingColumns[getObjectID(fk.ReferencedSchema, fk.ReferencedTable)] {
+ continue
+ }
+ if err := writeForeignKey(out, schema.Name, table.Name, fk); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
func writeTable(out io.Writer, schema string, table *storepb.TableMetadata, sequences []*storepb.SequenceMetadata) error {
+ if tableMissingColumnMetadata(table) {
+ // Emit a bare CREATE TABLE so the table still exists on replay, and
+ // skip constraints, indexes, partitions, and sequence ownership —
+ // they all reference columns absent from the dump.
+ if err := writeCreateTable(out, schema, table.Name, nil, nil, nil); err != nil {
+ return err
+ }
+ if _, err := io.WriteString(out, ";\n\n"); err != nil {
+ return err
+ }
+ if len(table.Comment) > 0 {
+ return writeTableComment(out, schema, table)
+ }
+ return nil
+ }
+
generationTypes, identitySequences, nonIdentitySequences := splitSequencesByIdentityOrNot(table, sequences)
if err := writeCreateTable(out, schema, table.Name, table.Columns, table.CheckConstraints, table.ExcludeConstraints); err != nil {
@@ -1698,9 +1742,13 @@ func writeTable(out io.Writer, schema string, table *storepb.TableMetadata, sequ
return err
}
- for _, sequence := range nonIdentitySequences {
- if err := writeAlterSequenceOwnedBy(out, schema, sequence); err != nil {
- return err
+ // Skip OWNED BY for a table with no columns; the clause would reference
+ // a column absent from the dump.
+ if !tableHasNoColumns(table) {
+ for _, sequence := range nonIdentitySequences {
+ if err := writeAlterSequenceOwnedBy(out, schema, sequence); err != nil {
+ return err
+ }
}
}
@@ -2496,6 +2544,9 @@ func writeExtensionComment(out io.Writer, extension *storepb.ExtensionMetadata)
func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {
var buf strings.Builder
+ tablesMissingColumns := collectTables(metadata.Schemas, tableMissingColumnMetadata)
+ tablesWithoutColumns := collectTables(metadata.Schemas, tableHasNoColumns)
+
// Write CREATE SCHEMA statements first for non-public schemas
for _, schema := range metadata.Schemas {
if schema.SkipDump {
@@ -2665,7 +2716,7 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {
tableSequences := tableSequencesMap[tableKey]
// Write CREATE TABLE statement
- if err := writeCreateTableSDL(&buf, schema.Name, table, tableSequences); err != nil {
+ if err := writeCreateTableSDL(&buf, schema.Name, table, tableSequences, tablesMissingColumns); err != nil {
return "", err
}
@@ -2694,13 +2745,17 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {
return "", err
}
- // Write index comments if present
- for _, index := range table.Indexes {
- // Only write comment for standalone indexes (not primary key or unique constraint indexes)
- if !index.Primary && !index.Unique {
- if len(index.Comment) > 0 {
- if err := writeIndexCommentSDL(&buf, schema.Name, index); err != nil {
- return "", err
+ // Write index comments if present. Skip when the table has no
+ // column metadata — its indexes were not emitted, so a COMMENT ON
+ // INDEX would target a nonexistent index.
+ if !tableMissingColumnMetadata(table) {
+ for _, index := range table.Indexes {
+ // Only write comment for standalone indexes (not primary key or unique constraint indexes)
+ if !index.Primary && !index.Unique {
+ if len(index.Comment) > 0 {
+ if err := writeIndexCommentSDL(&buf, schema.Name, index); err != nil {
+ return "", err
+ }
}
}
}
@@ -2711,11 +2766,14 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {
return "", err
}
- // Write trigger comments if present
- for _, trigger := range table.Triggers {
- if len(trigger.Comment) > 0 {
- if err := writeTriggerCommentSDL(&buf, schema.Name, table.Name, trigger); err != nil {
- return "", err
+ // Write trigger comments if present. Skip when the table has no
+ // column metadata — its triggers were not emitted.
+ if !tableMissingColumnMetadata(table) {
+ for _, trigger := range table.Triggers {
+ if len(trigger.Comment) > 0 {
+ if err := writeTriggerCommentSDL(&buf, schema.Name, table.Name, trigger); err != nil {
+ return "", err
+ }
}
}
}
@@ -2732,8 +2790,11 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {
if skipSequences[sequenceKey] {
continue
}
- // Write ALTER SEQUENCE OWNED BY for sequences with owners
- if sequence.OwnerTable != "" && sequence.OwnerColumn != "" {
+ // Write ALTER SEQUENCE OWNED BY for sequences with owners. Skip
+ // when the owning table has no columns; the OWNED BY clause
+ // would reference a column absent from the dump.
+ if sequence.OwnerTable != "" && sequence.OwnerColumn != "" &&
+ !tablesWithoutColumns[getObjectID(schema.Name, sequence.OwnerTable)] {
if err := writeAlterSequenceOwnedBy(&buf, schema.Name, sequence); err != nil {
return "", err
}
@@ -3133,7 +3194,7 @@ func writeColumnSDL(out io.Writer, column *storepb.ColumnMetadata, tableName str
return nil
}
-func writeCreateTableSDL(out io.Writer, schemaName string, table *storepb.TableMetadata, sequences []*storepb.SequenceMetadata) error {
+func writeCreateTableSDL(out io.Writer, schemaName string, table *storepb.TableMetadata, sequences []*storepb.SequenceMetadata, tablesMissingColumns map[string]bool) error {
if _, err := io.WriteString(out, `CREATE TABLE "`); err != nil {
return err
}
@@ -3178,7 +3239,7 @@ func writeCreateTableSDL(out io.Writer, schemaName string, table *storepb.TableM
}
// Write table constraints
- if err := writeTableConstraintsSDL(out, table, writeItemSep); err != nil {
+ if err := writeTableConstraintsSDL(out, table, writeItemSep, tablesMissingColumns); err != nil {
return err
}
@@ -3186,7 +3247,12 @@ func writeCreateTableSDL(out io.Writer, schemaName string, table *storepb.TableM
return err
}
-func writeTableConstraintsSDL(out io.Writer, table *storepb.TableMetadata, writeSep func() error) error {
+func writeTableConstraintsSDL(out io.Writer, table *storepb.TableMetadata, writeSep func() error, tablesMissingColumns map[string]bool) error {
+ if tableMissingColumnMetadata(table) {
+ // Constraints would reference columns absent from the dump.
+ return nil
+ }
+
// Write primary key constraint
for _, index := range table.Indexes {
if index.Primary {
@@ -3231,8 +3297,13 @@ func writeTableConstraintsSDL(out io.Writer, table *storepb.TableMetadata, write
}
}
- // Write foreign key constraints
+ // Write foreign key constraints. Skip foreign keys whose referenced
+ // table has no column metadata; the REFERENCES clause would name
+ // columns absent from the dump.
for _, fk := range table.ForeignKeys {
+ if tablesMissingColumns[getObjectID(fk.ReferencedSchema, fk.ReferencedTable)] {
+ continue
+ }
if err := writeSep(); err != nil {
return err
}
@@ -3245,6 +3316,10 @@ func writeTableConstraintsSDL(out io.Writer, table *storepb.TableMetadata, write
}
func writeIndexesSDL(out io.Writer, schemaName string, table *storepb.TableMetadata) error {
+ if tableMissingColumnMetadata(table) {
+ // Indexes would reference columns absent from the dump.
+ return nil
+ }
for _, index := range table.Indexes {
// Skip indexes that are constraints (primary key, unique constraints)
// These are already handled in the CREATE TABLE statement
@@ -3661,6 +3736,8 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s
// Build table sequences map for each table
tableSequencesMap := buildTableSequencesMap(metadata)
+ tablesMissingColumns := collectTables(metadata.Schemas, tableMissingColumnMetadata)
+
// Generate files for each schema
for _, schemaMetadata := range metadata.Schemas {
if schemaMetadata.SkipDump {
@@ -3713,7 +3790,7 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s
var buf strings.Builder
// Write CREATE TABLE statement in SDL format
- if err := writeCreateTableSDL(&buf, schemaName, table, tableSequences); err != nil {
+ if err := writeCreateTableSDL(&buf, schemaName, table, tableSequences, tablesMissingColumns); err != nil {
return nil, errors.Wrapf(err, "failed to generate table SDL for %s.%s", schemaName, table.Name)
}
buf.WriteString(";\n\n")
@@ -3739,13 +3816,17 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s
return nil, errors.Wrapf(err, "failed to generate indexes SDL for %s.%s", schemaName, table.Name)
}
- // Write index comments if present
- for _, index := range table.Indexes {
- // Only write comment for standalone indexes (not primary key or unique constraint indexes)
- if !index.Primary && !index.Unique {
- if len(index.Comment) > 0 {
- if err := writeIndexCommentSDL(&buf, schemaName, index); err != nil {
- return nil, errors.Wrapf(err, "failed to generate index comment for %s.%s", schemaName, index.Name)
+ // Write index comments if present. Skip when the table has no
+ // column metadata — its indexes were not emitted, so a COMMENT ON
+ // INDEX would target a nonexistent index.
+ if !tableMissingColumnMetadata(table) {
+ for _, index := range table.Indexes {
+ // Only write comment for standalone indexes (not primary key or unique constraint indexes)
+ if !index.Primary && !index.Unique {
+ if len(index.Comment) > 0 {
+ if err := writeIndexCommentSDL(&buf, schemaName, index); err != nil {
+ return nil, errors.Wrapf(err, "failed to generate index comment for %s.%s", schemaName, index.Name)
+ }
}
}
}
@@ -3756,11 +3837,14 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s
return nil, errors.Wrapf(err, "failed to generate triggers SDL for %s.%s", schemaName, table.Name)
}
- // Write trigger comments if present
- for _, trigger := range table.Triggers {
- if len(trigger.Comment) > 0 {
- if err := writeTriggerCommentSDL(&buf, schemaName, table.Name, trigger); err != nil {
- return nil, errors.Wrapf(err, "failed to generate trigger comment for %s.%s.%s", schemaName, table.Name, trigger.Name)
+ // Write trigger comments if present. Skip when the table has no
+ // column metadata — its triggers were not emitted.
+ if !tableMissingColumnMetadata(table) {
+ for _, trigger := range table.Triggers {
+ if len(trigger.Comment) > 0 {
+ if err := writeTriggerCommentSDL(&buf, schemaName, table.Name, trigger); err != nil {
+ return nil, errors.Wrapf(err, "failed to generate trigger comment for %s.%s.%s", schemaName, table.Name, trigger.Name)
+ }
}
}
}
@@ -3789,10 +3873,14 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s
}
}
- // Add ALTER SEQUENCE OWNED BY
- buf.WriteString("\n")
- if err := writeAlterSequenceOwnedBy(&buf, schemaName, sequence); err != nil {
- return nil, errors.Wrapf(err, "failed to generate ALTER SEQUENCE OWNED BY for %s.%s", schemaName, sequence.Name)
+ // Add ALTER SEQUENCE OWNED BY. Skip when the owning table
+ // has no columns; the OWNED BY clause would reference a
+ // column absent from the dump.
+ if !tableHasNoColumns(table) {
+ buf.WriteString("\n")
+ if err := writeAlterSequenceOwnedBy(&buf, schemaName, sequence); err != nil {
+ return nil, errors.Wrapf(err, "failed to generate ALTER SEQUENCE OWNED BY for %s.%s", schemaName, sequence.Name)
+ }
}
}
}
@@ -4328,6 +4416,11 @@ func writeIndexCommentSDL(out io.Writer, schemaName string, index *storepb.Index
}
func writeTriggersSDL(out io.Writer, schemaName string, table *storepb.TableMetadata) error {
+ if tableMissingColumnMetadata(table) {
+ // Trigger definitions (UPDATE OF, WHEN clauses) can reference
+ // columns absent from the dump.
+ return nil
+ }
for _, trigger := range table.Triggers {
if trigger.SkipDump {
continue
diff --git a/backend/plugin/schema/pg/get_database_definition_regressions_test.go b/backend/plugin/schema/pg/get_database_definition_regressions_test.go
index 3b3b39855e..fc85b37a7f 100644
--- a/backend/plugin/schema/pg/get_database_definition_regressions_test.go
+++ b/backend/plugin/schema/pg/get_database_definition_regressions_test.go
@@ -84,6 +84,12 @@ func TestGetDatabaseDefinition_TableWithOnlyCheckConstraints(t *testing.T) {
if !strings.Contains(ddl, `CREATE TABLE "public"."cons_only" (`) {
t.Errorf("expected CREATE TABLE for cons_only, got:\n%s", ddl)
}
+ // A genuine zero-column table (no indexes or foreign keys) must keep its
+ // column-independent CHECK constraint — only privilege-filtered broken
+ // metadata goes down the bare-table path.
+ if !strings.Contains(ddl, "cons_only_dummy") {
+ t.Errorf("expected CHECK constraint cons_only_dummy to be preserved, got:\n%s", ddl)
+ }
// Omni will reject a table with zero columns semantically, but it must
// at least parse cleanly; the test asserts the parse-level contract.
if _, parseErr := catalog.New().Exec(ddl, &catalog.ExecOptions{ContinueOnError: true}); parseErr != nil {
@@ -91,6 +97,194 @@ func TestGetDatabaseDefinition_TableWithOnlyCheckConstraints(t *testing.T) {
}
}
+// TestGetDatabaseDefinition_TableWithConstraintsButNoColumns reproduces a
+// dump replay failure observed on a real workspace export: the sync user
+// lacked column privileges on some tables, so information_schema.columns
+// returned nothing while pg_catalog still exposed the tables' constraints.
+// The dump then emitted `CREATE TABLE "s1"."t1" ();` followed by
+// `ALTER TABLE ... ADD CONSTRAINT ... PRIMARY KEY (c1, c2);`, which
+// PostgreSQL rejects because the columns do not exist. The dump must skip
+// column-dependent DDL for such tables instead of producing non-replayable
+// statements.
+func TestGetDatabaseDefinition_TableWithConstraintsButNoColumns(t *testing.T) {
+ meta := &storepb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*storepb.SchemaMetadata{{
+ Name: "s1",
+ Sequences: []*storepb.SequenceMetadata{
+ {
+ // Owned by a column missing from t1's metadata: the sequence
+ // itself must dump, its OWNED BY clause must not.
+ Name: "t1_c1_seq",
+ DataType: "bigint",
+ Start: "1",
+ Increment: "1",
+ MinValue: "1",
+ MaxValue: "9223372036854775807",
+ OwnerTable: "t1",
+ OwnerColumn: "c1",
+ },
+ {
+ // Owned by a column of t4, a zero-column table with no
+ // broken-metadata signal (no indexes/FKs/partitions):
+ // OWNED BY must still be skipped — a sequence cannot be
+ // owned by a column of a zero-column table.
+ Name: "t4_id_seq",
+ DataType: "bigint",
+ Start: "1",
+ Increment: "1",
+ MinValue: "1",
+ MaxValue: "9223372036854775807",
+ OwnerTable: "t4",
+ OwnerColumn: "id",
+ },
+ },
+ Tables: []*storepb.TableMetadata{
+ {
+ // Broken sync: constraints and indexes, but no columns.
+ Name: "t1",
+ Indexes: []*storepb.IndexMetadata{
+ {
+ Name: "pk_t1",
+ Primary: true,
+ Unique: true,
+ IsConstraint: true,
+ Expressions: []string{"c1", "c2"},
+ },
+ {
+ Name: "uk_t1_c1",
+ Unique: true,
+ IsConstraint: true,
+ Expressions: []string{"c1"},
+ },
+ {
+ Name: "idx_t1_c2",
+ Type: "btree",
+ Expressions: []string{"c2"},
+ Definition: `CREATE INDEX idx_t1_c2 ON s1.t1 USING btree (c2);`,
+ Comment: "comment on a never-created index",
+ },
+ },
+ CheckConstraints: []*storepb.CheckConstraintMetadata{{
+ Name: "chk_t1_c1",
+ Expression: "(c1 > 0)",
+ }},
+ ForeignKeys: []*storepb.ForeignKeyMetadata{{
+ Name: "fk_t1_t2",
+ Columns: []string{"c1"},
+ ReferencedSchema: "s1",
+ ReferencedTable: "t2",
+ ReferencedColumns: []string{"id"},
+ }},
+ Triggers: []*storepb.TriggerMetadata{{
+ Name: "trg_t1_c1",
+ Body: `CREATE TRIGGER trg_t1_c1 BEFORE UPDATE OF c1 ON s1.t1 FOR EACH ROW EXECUTE FUNCTION s1.f()`,
+ Comment: "comment on a never-created trigger",
+ }},
+ Rules: []*storepb.RuleMetadata{{
+ Name: "rule_t1",
+ Event: "INSERT",
+ Definition: `CREATE RULE rule_t1 AS ON INSERT TO s1.t1 WHERE new.c1 > 0 DO INSTEAD NOTHING;`,
+ }},
+ },
+ {
+ // Healthy table; its own constraints must still dump, but
+ // its foreign key into the broken table must not.
+ Name: "t2",
+ Columns: []*storepb.ColumnMetadata{
+ {Name: "id", Type: "integer", Nullable: false},
+ {Name: "t1_c1", Type: "integer", Nullable: true},
+ },
+ Indexes: []*storepb.IndexMetadata{{
+ Name: "pk_t2",
+ Primary: true,
+ Unique: true,
+ IsConstraint: true,
+ Expressions: []string{"id"},
+ }},
+ ForeignKeys: []*storepb.ForeignKeyMetadata{{
+ Name: "fk_t2_t1",
+ Columns: []string{"t1_c1"},
+ ReferencedSchema: "s1",
+ ReferencedTable: "t1",
+ ReferencedColumns: []string{"c1"},
+ }},
+ },
+ {
+ // Broken sync on a partitioned table with no indexes: the
+ // partition key references missing columns, so the table
+ // must dump bare, without the PARTITION BY clause.
+ Name: "t3",
+ Partitions: []*storepb.TablePartitionMetadata{{
+ Name: "t3_p1",
+ Expression: "RANGE (created_at)",
+ }},
+ },
+ {
+ // Genuine zero-column table: no indexes, foreign keys, or
+ // partitions. Its column-independent CHECK must be kept.
+ Name: "t4",
+ CheckConstraints: []*storepb.CheckConstraintMetadata{{
+ Name: "chk_t4_ok",
+ Expression: "(1 = 1)",
+ }},
+ },
+ },
+ }},
+ }
+
+ banned := []string{"pk_t1", "uk_t1_c1", "idx_t1_c2", "chk_t1_c1", "fk_t1_t2", "fk_t2_t1", "trg_t1_c1", "rule_t1", "t3_p1", "PARTITION BY", "OWNED BY", "COMMENT ON INDEX"}
+
+ for name, ctx := range map[string]schema.GetDefinitionContext{
+ "dump": {},
+ "sdl": {SDLFormat: true},
+ } {
+ ddl, err := GetDatabaseDefinition(ctx, meta)
+ if err != nil {
+ t.Fatalf("[%s] GetDatabaseDefinition: %v", name, err)
+ }
+
+ if !strings.Contains(ddl, `CREATE TABLE "s1"."t1" (`) {
+ t.Errorf("[%s] expected bare CREATE TABLE for t1, got:\n%s", name, ddl)
+ }
+ for _, b := range banned {
+ if strings.Contains(ddl, b) {
+ t.Errorf("[%s] DDL references %q, which depends on columns missing from t1's metadata; got:\n%s", name, b, ddl)
+ }
+ }
+ if !strings.Contains(ddl, "pk_t2") {
+ t.Errorf("[%s] expected pk_t2 on the healthy table, got:\n%s", name, ddl)
+ }
+ if !strings.Contains(ddl, `CREATE SEQUENCE "s1"."t1_c1_seq"`) {
+ t.Errorf("[%s] expected CREATE SEQUENCE for t1_c1_seq, got:\n%s", name, ddl)
+ }
+ if !strings.Contains(ddl, `CREATE TABLE "s1"."t3" (`) {
+ t.Errorf("[%s] expected bare CREATE TABLE for t3, got:\n%s", name, ddl)
+ }
+ if !strings.Contains(ddl, "chk_t4_ok") {
+ t.Errorf("[%s] expected genuine zero-column table t4 to keep its CHECK constraint, got:\n%s", name, ddl)
+ }
+
+ if _, parseErr := catalog.New().Exec(ddl, &catalog.ExecOptions{ContinueOnError: true}); parseErr != nil {
+ t.Errorf("[%s] omni catalog parse error: %v\nDDL:\n%s", name, parseErr, ddl)
+ }
+ }
+
+ multiFile, err := GetMultiFileDatabaseDefinition(schema.GetDefinitionContext{}, meta)
+ if err != nil {
+ t.Fatalf("GetMultiFileDatabaseDefinition: %v", err)
+ }
+ var combined strings.Builder
+ for _, file := range multiFile.Files {
+ combined.WriteString(file.Content)
+ }
+ for _, b := range banned {
+ if strings.Contains(combined.String(), b) {
+ t.Errorf("[multi-file] DDL references %q, which depends on columns missing from t1's metadata; got:\n%s", b, combined.String())
+ }
+ }
+}
+
// TestGetDatabaseDefinition_TableNameContainingDot reproduces A3: a table
// whose name literally contains a period was writing out as `"".".."` —
// because the schema + "." + object object-ID was split back on the first