Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(pg): handle cyclic FK dependencies and unify schema diff code (#18820)
rebelice573f20f56bfd
diff --git a/backend/plugin/schema/pg/generate_migration.go b/backend/plugin/schema/pg/generate_migration.goindex 8bbef2104d..0f14c7e4ec 100644--- a/backend/plugin/schema/pg/generate_migration.go+++ b/backend/plugin/schema/pg/generate_migration.go@@ -674,13 +674,11 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {}}-// createObjectsInOrder creates all objects in topological order (dependencies first)-func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error {- // First create schemas (they don't have dependencies)+// createSchemas creates all new schemas.+func createSchemas(diff *schema.MetadataDiff, buf *strings.Builder) error {var schemasToCreate []stringfor _, schemaDiff := range diff.SchemaChanges {if schemaDiff.Action == schema.MetadataDiffActionCreate {- // Skip creating pg_catalog and public schemas as they already exist by defaultif schemaDiff.SchemaName != "pg_catalog" && schemaDiff.SchemaName != "public" {schemasToCreate = append(schemasToCreate, schemaDiff.SchemaName)}@@ -692,59 +690,57 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) errorreturn err}}-- // Add blank line after schema creation only if we have schemas and more content followsif len(schemasToCreate) > 0 && (hasCreateOrAlterTables(diff) || hasCreateViewsOrFunctions(diff)) {_, _ = buf.WriteString("\n")}+ return nil+}- // Create extensions (before enum types and tables as they might provide types used in definitions)+// createExtensions creates all new extensions.+func createExtensions(diff *schema.MetadataDiff, buf *strings.Builder) error {for _, extDiff := range diff.ExtensionChanges {if extDiff.Action == schema.MetadataDiffActionCreate {- // Support both metadata and AST-only modesif extDiff.NewExtension != nil {- // Metadata mode: use extension metadataif err := writeCreateExtension(buf, extDiff.NewExtension); err != nil {return err}} else if extDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST nodeif err := writeMigrationExtensionFromAST(buf, extDiff.NewASTNode); err != nil {return err}}}}+ return nil+}- // Create enum types (before tables as they might be used in column definitions)+// createEnumTypes creates all new enum types.+func createEnumTypes(diff *schema.MetadataDiff, buf *strings.Builder) error {for _, enumDiff := range diff.EnumTypeChanges {if enumDiff.Action == schema.MetadataDiffActionCreate {- // Support both metadata and AST-only modesif enumDiff.NewEnumType != nil {- // Metadata mode: use enum type metadataif err := writeCreateEnumType(buf, enumDiff.SchemaName, enumDiff.NewEnumType); err != nil {return err}} else if enumDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST nodeif err := writeMigrationEnumTypeFromAST(buf, enumDiff.NewASTNode); err != nil {return err}}}}+ return nil+}- // Create sequences (before tables as they might be used in column defaults)+// createSequences creates all new sequences.+func createSequences(diff *schema.MetadataDiff, buf *strings.Builder) error {for _, seqDiff := range diff.SequenceChanges {if seqDiff.Action == schema.MetadataDiffActionCreate {- // Support both metadata and AST-only modesif seqDiff.NewSequence != nil {- // Metadata mode: use sequence metadataif err := writeMigrationCreateSequence(buf, seqDiff.SchemaName, seqDiff.NewSequence); err != nil {return err}} else if seqDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST nodeif err := writeMigrationSequenceFromAST(buf, seqDiff.NewASTNode); err != nil {return err}@@ -753,625 +749,299 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}}+ return nil+}- // Build dependency graph for all objects being created or altered- graph := base.NewGraph()-- // Build temporary metadata for AST-only mode dependency extraction- // This metadata contains tables and views that are being created,- // allowing GetQuerySpan to find them when extracting view dependencies- tempMetadata := buildTempMetadataForCreate(diff)-- // Maps to store different object types- viewMap := make(map[string]*schema.ViewDiff)- materializedViewMap := make(map[string]*schema.MaterializedViewDiff)- tableMap := make(map[string]*schema.TableDiff)- functionMap := make(map[string]*schema.FunctionDiff)-- // Track all object IDs for dependency resolution- allObjects := make(map[string]bool)+// objectMaps holds maps of different object types for migration generation.+type objectMaps struct {+ tables map[string]*schema.TableDiff+ views map[string]*schema.ViewDiff+ materializedViews map[string]*schema.MaterializedViewDiff+ functions map[string]*schema.FunctionDiff+}- // Add tables to graph (both CREATE and ALTER for column additions)- for _, tableDiff := range diff.TableChanges {- if tableDiff.Action == schema.MetadataDiffActionCreate || tableDiff.Action == schema.MetadataDiffActionAlter {- tableID := getMigrationObjectID(tableDiff.SchemaName, tableDiff.TableName)- graph.AddNode(tableID)- tableMap[tableID] = tableDiff- allObjects[tableID] = true- }+// buildObjectMaps creates maps for all CREATE/ALTER objects.+func buildObjectMaps(diff *schema.MetadataDiff) *objectMaps {+ m := &objectMaps{+ tables: make(map[string]*schema.TableDiff),+ views: make(map[string]*schema.ViewDiff),+ materializedViews: make(map[string]*schema.MaterializedViewDiff),+ functions: make(map[string]*schema.FunctionDiff),}-- // Add views to graph- for _, viewDiff := range diff.ViewChanges {- if viewDiff.Action == schema.MetadataDiffActionCreate || viewDiff.Action == schema.MetadataDiffActionAlter {- viewID := getMigrationObjectID(viewDiff.SchemaName, viewDiff.ViewName)- graph.AddNode(viewID)- viewMap[viewID] = viewDiff- allObjects[viewID] = true+ for _, d := range diff.TableChanges {+ if d.Action == schema.MetadataDiffActionCreate || d.Action == schema.MetadataDiffActionAlter {+ m.tables[getMigrationObjectID(d.SchemaName, d.TableName)] = d}}-- // Add materialized views to graph- for _, mvDiff := range diff.MaterializedViewChanges {- if mvDiff.Action == schema.MetadataDiffActionCreate || mvDiff.Action == schema.MetadataDiffActionAlter {- mvID := getMigrationObjectID(mvDiff.SchemaName, mvDiff.MaterializedViewName)- graph.AddNode(mvID)- materializedViewMap[mvID] = mvDiff- allObjects[mvID] = true+ for _, d := range diff.ViewChanges {+ if d.Action == schema.MetadataDiffActionCreate || d.Action == schema.MetadataDiffActionAlter {+ m.views[getMigrationObjectID(d.SchemaName, d.ViewName)] = d}}-- // Add functions to graph- for _, funcDiff := range diff.FunctionChanges {- if funcDiff.Action == schema.MetadataDiffActionCreate || funcDiff.Action == schema.MetadataDiffActionAlter {- funcID := getMigrationObjectID(funcDiff.SchemaName, funcDiff.FunctionName)- graph.AddNode(funcID)- functionMap[funcID] = funcDiff- allObjects[funcID] = true+ for _, d := range diff.MaterializedViewChanges {+ if d.Action == schema.MetadataDiffActionCreate || d.Action == schema.MetadataDiffActionAlter {+ m.materializedViews[getMigrationObjectID(d.SchemaName, d.MaterializedViewName)] = d}}-- // Add triggers to graph (only for CREATE table operations)- // Triggers on ALTER tables are handled separately via generateAlterTableTriggers- triggerMap := make(map[string]*schema.TriggerDiff)- for _, tableDiff := range diff.TableChanges {- // Only add triggers for CREATE table operations- // ALTER table triggers are handled in generateAlterTableTriggers to avoid duplicates- if tableDiff.Action == schema.MetadataDiffActionCreate {- for _, triggerDiff := range tableDiff.TriggerChanges {- if triggerDiff.Action == schema.MetadataDiffActionCreate {- triggerID := getTriggerObjectID(triggerDiff)- graph.AddNode(triggerID)- triggerMap[triggerID] = triggerDiff- allObjects[triggerID] = true- }- }+ for _, d := range diff.FunctionChanges {+ if d.Action == schema.MetadataDiffActionCreate || d.Action == schema.MetadataDiffActionAlter {+ m.functions[getMigrationObjectID(d.SchemaName, d.FunctionName)] = d}}+ return m+}- // Add dependency edges- // For tables with foreign keys depending on other tables (only for CREATE operations)- // Note: ALTER FK additions are handled after all tables are created, so they don't need topological sorting- for tableID, tableDiff := range tableMap {+// createTables creates tables, detecting FK cycles and handling them appropriately.+// Returns true if there's a FK cycle.+func createTables(buf *strings.Builder, maps *objectMaps) (bool, error) {+ // Detect FK cycle in CREATE tables+ tableGraph := base.NewGraph()+ for tableID, tableDiff := range maps.tables {if tableDiff.Action == schema.MetadataDiffActionCreate {- // For CREATE: extract all FKs from the table+ tableGraph.AddNode(tableID)var foreignKeys []*storepb.ForeignKeyMetadata-if tableDiff.NewTable != nil {- // Metadata mode: use ForeignKeys from metadataforeignKeys = tableDiff.NewTable.ForeignKeys} else if tableDiff.NewASTNode != nil {- // AST-only mode: extract foreign keys from AST nodeforeignKeys = extractForeignKeysFromAST(tableDiff.NewASTNode, tableDiff.SchemaName)}-for _, fk := range foreignKeys {depID := getMigrationObjectID(fk.ReferencedSchema, fk.ReferencedTable)if depID != tableID {- // Edge from dependency to dependent (referenced table to table with FK)- graph.AddEdge(depID, tableID)+ tableGraph.AddEdge(depID, tableID)}}}}+ orderedList, err := tableGraph.TopologicalSort()+ hasCycle := err != nil- // For views depending on tables/views- for viewID, viewDiff := range viewMap {- var dependencies []*storepb.DependencyColumn+ if hasCycle {+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeCreateTableDiff(buf, tableDiff, false); err != nil {+ return hasCycle, err+ }+ writeTableIndexesForCreate(buf, tableDiff)+ }+ }+ } else {+ for _, tableID := range orderedList {+ tableDiff := maps.tables[tableID]+ if tableDiff == nil {+ // Skip tables not in the map (e.g., existing referenced tables added via AddEdge)+ continue+ }+ if tableDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeCreateTableDiff(buf, tableDiff, true); err != nil {+ return hasCycle, err+ }+ writeTableIndexesForCreate(buf, tableDiff)+ }+ }+ }+ return hasCycle, nil+}+// alterTables handles ALTER table operations (without FK).+func alterTables(buf *strings.Builder, maps *objectMaps) error {+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionAlter {+ sql, err := generateAlterTableWithOptions(tableDiff, true)+ if err != nil {+ return err+ }+ if sql != "" {+ _, _ = buf.WriteString(sql)+ _, _ = buf.WriteString("\n")+ }+ }+ }+ return nil+}++// createViewsMVsFunctions creates views, materialized views, and functions in dependency order.+func createViewsMVsFunctions(buf *strings.Builder, maps *objectMaps, tempMetadata *storepb.DatabaseSchemaMetadata) error {+ graph := base.NewGraph()+ nonTableObjects := make(map[string]bool)++ for id := range maps.views {+ graph.AddNode(id)+ nonTableObjects[id] = true+ }+ for id := range maps.materializedViews {+ graph.AddNode(id)+ nonTableObjects[id] = true+ }+ for id := range maps.functions {+ graph.AddNode(id)+ nonTableObjects[id] = true+ }++ // Add dependency edges for views+ for viewID, viewDiff := range maps.views {+ var deps []*storepb.DependencyColumnif viewDiff.NewView != nil {- // Use metadata if available- dependencies = viewDiff.NewView.DependencyColumns+ deps = viewDiff.NewView.DependencyColumns} else if viewDiff.NewASTNode != nil {- // Extract dependencies from AST node for AST-only mode- // Use the temporary metadata containing objects being created- dependencies = getViewDependenciesFromAST(viewDiff.NewASTNode, viewDiff.SchemaName, tempMetadata)+ deps = getViewDependenciesFromAST(viewDiff.NewASTNode, viewDiff.SchemaName, tempMetadata)}-- for _, dep := range dependencies {+ for _, dep := range deps {depID := getMigrationObjectID(dep.Schema, dep.Table)- if allObjects[depID] {- // Edge from dependency to dependent (table/view to view)+ if nonTableObjects[depID] {graph.AddEdge(depID, viewID)}}}-- // For materialized views depending on tables/views- for mvID, mvDiff := range materializedViewMap {- var dependencies []*storepb.DependencyColumn-+ // Add dependency edges for materialized views+ for mvID, mvDiff := range maps.materializedViews {+ var deps []*storepb.DependencyColumnif mvDiff.NewMaterializedView != nil {- // Use metadata if available- dependencies = mvDiff.NewMaterializedView.DependencyColumns+ deps = mvDiff.NewMaterializedView.DependencyColumns} else if mvDiff.NewASTNode != nil {- // Extract dependencies from AST node for AST-only mode- // Use the temporary metadata containing objects being created- dependencies = getMaterializedViewDependenciesFromAST(mvDiff.NewASTNode, mvDiff.SchemaName, tempMetadata)+ deps = getMaterializedViewDependenciesFromAST(mvDiff.NewASTNode, mvDiff.SchemaName, tempMetadata)}-- for _, dep := range dependencies {+ for _, dep := range deps {depID := getMigrationObjectID(dep.Schema, dep.Table)- if allObjects[depID] {- // Edge from dependency to dependent (table/view to materialized view)+ if nonTableObjects[depID] {graph.AddEdge(depID, mvID)}}}- // For functions depending on tables- for funcID, funcDiff := range functionMap {- if funcDiff.NewFunction != nil {- for _, dep := range funcDiff.NewFunction.DependencyTables {- depID := getMigrationObjectID(dep.Schema, dep.Table)- // Edge from table to function- graph.AddEdge(depID, funcID)- }- }- }-- // For triggers depending on tables and functions- for triggerID, triggerDiff := range triggerMap {- // Trigger depends on table- tableID := getMigrationObjectID(triggerDiff.SchemaName, triggerDiff.TableName)- if allObjects[tableID] {- graph.AddEdge(tableID, triggerID)- }-- // Trigger depends on trigger function- if triggerDiff.NewASTNode != nil {- functionName := extractTriggerFunctionName(triggerDiff.NewASTNode)- if functionName != "" {- parts := strings.Split(functionName, ".")- var functionSchemaName, functionNameOnly string- if len(parts) == 2 {- functionSchemaName, functionNameOnly = parts[0], parts[1]- } else {- functionSchemaName, functionNameOnly = triggerDiff.SchemaName, functionName- }- functionID := getMigrationObjectID(functionSchemaName, functionNameOnly)- if allObjects[functionID] {- graph.AddEdge(functionID, triggerID)- }- }- }- }-- // Get topological orderorderedList, err := graph.TopologicalSort()if err != nil {- // If there's a cycle, fall back to a safe order- // Create tables first (without foreign keys)- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionCreate {- // Support both metadata mode and AST-only mode- if tableDiff.NewTable != nil {- // Metadata mode: use generateCreateTable- createTableSQL, err := generateCreateTable(tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable, false)- if err != nil {- return err- }- _, _ = buf.WriteString(createTableSQL)- if createTableSQL != "" {- _, _ = buf.WriteString("\n")- }-- // Add table and column comments for newly created tables- if tableDiff.NewTable.Comment != "" {- writeCommentOnTable(buf, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable.Comment)- }- for _, col := range tableDiff.NewTable.Columns {- if col.Comment != "" {- writeCommentOnColumn(buf, tableDiff.SchemaName, tableDiff.TableName, col.Name, col.Comment)- }- }- } else if tableDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST node WITHOUT foreign keys- // FK constraints will be added separately after all tables are created- if err := writeMigrationTableFromASTWithoutFK(buf, tableDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("table CREATE action requires either NewTable metadata or NewASTNode for table %s.%s", tableDiff.SchemaName, tableDiff.TableName)- }-- // Add indexes for newly created tables immediately after table creation- // This is necessary because later tables might have FK that reference indexed columns- for _, indexDiff := range tableDiff.IndexChanges {- if indexDiff.Action == schema.MetadataDiffActionCreate {- if indexDiff.NewIndex != nil {- // Metadata mode: use index metadata- if indexDiff.NewIndex.IsConstraint {- // Skip constraint-based indexes (primary key, unique, exclude)- // They are already included in CREATE TABLE statement- continue- }- writeMigrationIndex(buf, tableDiff.SchemaName, tableDiff.TableName, indexDiff.NewIndex)- } else if indexDiff.NewASTNode != nil {- // AST-only mode: extract from AST node- if indexAST, ok := indexDiff.NewASTNode.(*pgparser.IndexstmtContext); ok {- if err := writeCreateIndexFromAST(buf, indexAST); err != nil {- // If AST extraction fails, log error but continue (non-fatal)- _, _ = fmt.Fprintf(buf, "-- Error creating index: %v\n", err)- }- }- }- }- }- }- }-- // Handle column additions for ALTER operations (only columns in topological order)- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionAlter {- for _, colDiff := range tableDiff.ColumnChanges {- if colDiff.Action == schema.MetadataDiffActionCreate {- writeAddColumn(buf, tableDiff.SchemaName, tableDiff.TableName, colDiff.NewColumn)- }- }+ // Fallback: create in map iteration order+ for _, d := range maps.views {+ if err := writeViewDiff(buf, d); err != nil {+ return err}}-- // Create views- for _, viewDiff := range viewMap {- switch viewDiff.Action {- case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:- // Support AST-only mode: if metadata is nil but AST node exists, use AST- if viewDiff.NewView != nil {- if err := writeMigrationView(buf, viewDiff.SchemaName, viewDiff.NewView); err != nil {- return err- }- } else if viewDiff.NewASTNode != nil {- if err := writeMigrationViewFromAST(buf, viewDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("view diff for %s.%s has neither metadata nor AST node", viewDiff.SchemaName, viewDiff.ViewName)- }- default:- // No action needed- }- // Add view comment for newly created views- if viewDiff.NewView != nil && viewDiff.NewView.Comment != "" {- writeCommentOnView(buf, viewDiff.SchemaName, viewDiff.ViewName, viewDiff.NewView.Comment)+ for _, d := range maps.materializedViews {+ if err := writeMaterializedViewDiff(buf, d); err != nil {+ return err}}-- // Create materialized views- for _, mvDiff := range materializedViewMap {- switch mvDiff.Action {- case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:- // Support AST-only mode: if metadata is nil but AST node exists, use AST- if mvDiff.NewMaterializedView != nil {- if err := writeMigrationMaterializedView(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView); err != nil {- return err- }- } else if mvDiff.NewASTNode != nil {- if err := writeMigrationMaterializedViewFromAST(buf, mvDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("materialized view diff for %s.%s has neither metadata nor AST node", mvDiff.SchemaName, mvDiff.MaterializedViewName)- }- default:- // No action needed+ for _, d := range maps.functions {+ if err := writeFunctionDiff(buf, d); err != nil {+ return err}- // Add materialized view comment for newly created materialized views- if mvDiff.NewMaterializedView != nil && mvDiff.NewMaterializedView.Comment != "" {- writeCommentOnMaterializedView(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName, mvDiff.NewMaterializedView.Comment)+ if d.Action == schema.MetadataDiffActionCreate && d.NewFunction != nil && d.NewFunction.Comment != "" {+ writeCommentOnFunction(buf, d.SchemaName, d.NewFunction.Signature, d.NewFunction.Comment, d.NewASTNode, d.NewFunction.Definition)}}+ return nil+ }- // Create functions- for _, funcDiff := range functionMap {- if err := writeFunctionDiff(buf, funcDiff); err != nil {+ for _, objID := range orderedList {+ if d, ok := maps.views[objID]; ok {+ if err := writeViewDiff(buf, d); err != nil {return err}- // Add function comment for newly created functions- if funcDiff.Action == schema.MetadataDiffActionCreate && funcDiff.NewFunction != nil && funcDiff.NewFunction.Comment != "" {- writeCommentOnFunction(buf, funcDiff.SchemaName, funcDiff.NewFunction.Signature, funcDiff.NewFunction.Comment, funcDiff.NewASTNode, funcDiff.NewFunction.Definition)- }- }-- // Set sequence ownership after all tables are created- for _, seqDiff := range diff.SequenceChanges {- if seqDiff.Action == schema.MetadataDiffActionCreate && seqDiff.NewSequence != nil && seqDiff.NewSequence.OwnerTable != "" && seqDiff.NewSequence.OwnerColumn != "" {- if err := writeMigrationSequenceOwnership(buf, seqDiff.SchemaName, seqDiff.NewSequence); err != nil {- return err- }+ } else if d, ok := maps.materializedViews[objID]; ok {+ if err := writeMaterializedViewDiff(buf, d); err != nil {+ return err}- }-- // Add foreign keys (only for CREATE table operations)- // First handle metadata mode- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewTable != nil {- for _, fk := range tableDiff.NewTable.ForeignKeys {- if err := writeMigrationForeignKey(buf, tableDiff.SchemaName, tableDiff.TableName, fk); err != nil {- return err- }- }+ } else if d, ok := maps.functions[objID]; ok {+ if err := writeFunctionDiff(buf, d); err != nil {+ return err}- }- // Then handle FK constraints that were excluded from CREATE TABLE- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewASTNode != nil {- if len(tableDiff.ForeignKeyChanges) > 0 {- // FKs are in ForeignKeyChanges (metadata mode or mixed mode)- for _, fkDiff := range tableDiff.ForeignKeyChanges {- if fkDiff.Action == schema.MetadataDiffActionCreate {- if fkDiff.NewForeignKey != nil {- // Metadata mode FK- if err := writeMigrationForeignKey(buf, tableDiff.SchemaName, tableDiff.TableName, fkDiff.NewForeignKey); err != nil {- return err- }- } else if fkDiff.NewASTNode != nil {- // AST mode FK- if constraintAST, ok := fkDiff.NewASTNode.(pgparser.ITableconstraintContext); ok {- if err := writeAddForeignKeyFromAST(buf, tableDiff.SchemaName, tableDiff.TableName, constraintAST); err != nil {- // Log error but continue - this is a best-effort operation- _, _ = fmt.Fprintf(buf, "-- Error adding foreign key constraint: %v\n", err)- }- }- }- }- }- } else {- // Pure AST mode - FKs are embedded in the AST node itself- // Extract FK constraints directly from the CREATE TABLE AST- writeAllForeignKeysFromTableAST(buf, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewASTNode)- }+ if d.Action == schema.MetadataDiffActionCreate && d.NewFunction != nil && d.NewFunction.Comment != "" {+ writeCommentOnFunction(buf, d.SchemaName, d.NewFunction.Signature, d.NewFunction.Comment, d.NewASTNode, d.NewFunction.Definition)}}- } else {- // Follow topological order completely - create objects in dependency order- for _, objID := range orderedList {- if tableDiff, ok := tableMap[objID]; ok {- switch tableDiff.Action {- case schema.MetadataDiffActionCreate:- // Support both metadata mode and AST-only mode- if tableDiff.NewTable != nil {- // Metadata mode: use generateCreateTable- createTableSQL, err := generateCreateTable(tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable, false)- if err != nil {- return err- }- _, _ = buf.WriteString(createTableSQL)- if createTableSQL != "" {- _, _ = buf.WriteString("\n")- }-- // Add table and column comments for newly created tables- if tableDiff.NewTable.Comment != "" {- writeCommentOnTable(buf, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable.Comment)- }- for _, col := range tableDiff.NewTable.Columns {- if col.Comment != "" {- writeCommentOnColumn(buf, tableDiff.SchemaName, tableDiff.TableName, col.Name, col.Comment)- }- }- } else if tableDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST node- if err := writeMigrationTableFromAST(buf, tableDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("table CREATE action requires either NewTable metadata or NewASTNode for table %s.%s", tableDiff.SchemaName, tableDiff.TableName)- }+ }+ return nil+}- // Add indexes for newly created tables immediately after table creation- // This is necessary because later tables might have FK that reference indexed columns- for _, indexDiff := range tableDiff.IndexChanges {- if indexDiff.Action == schema.MetadataDiffActionCreate {- if indexDiff.NewIndex != nil {- // Metadata mode: use index metadata- if indexDiff.NewIndex.IsConstraint {- // Skip constraint-based indexes (primary key, unique, exclude)- // They are already included in CREATE TABLE statement- continue- }- writeMigrationIndex(buf, tableDiff.SchemaName, tableDiff.TableName, indexDiff.NewIndex)- } else if indexDiff.NewASTNode != nil {- // AST-only mode: extract from AST node- if indexAST, ok := indexDiff.NewASTNode.(*pgparser.IndexstmtContext); ok {- if err := writeCreateIndexFromAST(buf, indexAST); err != nil {- // If AST extraction fails, log error but continue (non-fatal)- _, _ = fmt.Fprintf(buf, "-- Error creating index: %v\n", err)- }- }- }- }- }- case schema.MetadataDiffActionAlter:- // Handle ALTER table operations with generateAlterTableWithOptions- // Skip foreign keys in the first pass to avoid dependency issues- alterTableSQL, err := generateAlterTableWithOptions(tableDiff, true)- if err != nil {- return err- }- _, _ = buf.WriteString(alterTableSQL)- if alterTableSQL != "" {- _, _ = buf.WriteString("\n")- }- default:- // No action needed for other operations- }- } else if viewDiff, ok := viewMap[objID]; ok {- switch viewDiff.Action {- case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:- // Support AST-only mode: if metadata is nil but AST node exists, use AST- if viewDiff.NewView != nil {- if err := writeMigrationView(buf, viewDiff.SchemaName, viewDiff.NewView); err != nil {- return err- }- } else if viewDiff.NewASTNode != nil {- if err := writeMigrationViewFromAST(buf, viewDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("view diff for %s.%s has neither metadata nor AST node", viewDiff.SchemaName, viewDiff.ViewName)- }- default:- // No action needed for other operations- }- // Add view comment for newly created or altered views- if viewDiff.NewView != nil && viewDiff.NewView.Comment != "" {- writeCommentOnView(buf, viewDiff.SchemaName, viewDiff.ViewName, viewDiff.NewView.Comment)- }- } else if mvDiff, ok := materializedViewMap[objID]; ok {- switch mvDiff.Action {- case schema.MetadataDiffActionCreate:- // Support AST-only mode: if metadata is nil but AST node exists, use AST- if mvDiff.NewMaterializedView != nil {- if err := writeMigrationMaterializedView(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView); err != nil {- return err- }- } else if mvDiff.NewASTNode != nil {- if err := writeMigrationMaterializedViewFromAST(buf, mvDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("materialized view diff for %s.%s has neither metadata nor AST node", mvDiff.SchemaName, mvDiff.MaterializedViewName)- }- case schema.MetadataDiffActionAlter:- // Check if this is an index-only change (no MV definition change)- hasIndexOnlyChanges := len(mvDiff.IndexChanges) > 0 && mvDiff.NewMaterializedView == nil && mvDiff.NewASTNode == nil-- // For index-only changes, don't alter the MV itself- // Index changes are processed separately later (see lines ~1107-1127)- if !hasIndexOnlyChanges {- // For PostgreSQL materialized views, we need to drop and recreate- // since ALTER MATERIALIZED VIEW doesn't support changing the definition- writeDropMaterializedView(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName)- // Support AST-only mode- if mvDiff.NewMaterializedView != nil {- if err := writeMigrationMaterializedView(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView); err != nil {- return err- }- } else if mvDiff.NewASTNode != nil {- if err := writeMigrationMaterializedViewFromAST(buf, mvDiff.NewASTNode); err != nil {- return err- }- } else {- return errors.Errorf("materialized view ALTER for %s.%s has neither metadata nor AST node", mvDiff.SchemaName, mvDiff.MaterializedViewName)- }- }- default:- // No action needed for other operations- }- // Add materialized view comment for newly created or altered materialized views- if mvDiff.NewMaterializedView != nil && mvDiff.NewMaterializedView.Comment != "" {- writeCommentOnMaterializedView(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName, mvDiff.NewMaterializedView.Comment)- }- } else if funcDiff, ok := functionMap[objID]; ok {- if err := writeFunctionDiff(buf, funcDiff); err != nil {- return err- }- // Add function comment for newly created or altered functions- if (funcDiff.Action == schema.MetadataDiffActionCreate || funcDiff.Action == schema.MetadataDiffActionAlter) && funcDiff.NewFunction != nil && funcDiff.NewFunction.Comment != "" {- writeCommentOnFunction(buf, funcDiff.SchemaName, funcDiff.NewFunction.Signature, funcDiff.NewFunction.Comment, funcDiff.NewASTNode, funcDiff.NewFunction.Definition)- }- } else if triggerDiff, ok := triggerMap[objID]; ok {- // Handle triggers (both CREATE and ALTER use CREATE OR REPLACE)- if triggerDiff.Action == schema.MetadataDiffActionCreate || triggerDiff.Action == schema.MetadataDiffActionAlter {+// createTriggers creates triggers for new tables.+func createTriggers(buf *strings.Builder, maps *objectMaps) error {+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionCreate {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionCreate {if err := writeCreateTrigger(buf, triggerDiff); err != nil {return err}}}}+ }+ return nil+}- // Set sequence ownership after all tables are created- for _, seqDiff := range diff.SequenceChanges {- if seqDiff.Action == schema.MetadataDiffActionCreate && seqDiff.NewSequence != nil && seqDiff.NewSequence.OwnerTable != "" && seqDiff.NewSequence.OwnerColumn != "" {- if err := writeMigrationSequenceOwnership(buf, seqDiff.SchemaName, seqDiff.NewSequence); err != nil {+// addForeignKeys adds FK constraints after tables are created.+func addForeignKeys(buf *strings.Builder, maps *objectMaps, hasFKCycle bool) error {+ if hasFKCycle {+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionCreate {+ if err := writeTableForeignKeysForCreate(buf, tableDiff); err != nil {return err}}}-- // Add foreign keys after all tables are created (only for CREATE table operations)- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewTable != nil {- for _, fk := range tableDiff.NewTable.ForeignKeys {- if err := writeMigrationForeignKey(buf, tableDiff.SchemaName, tableDiff.TableName, fk); err != nil {- return err- }- }+ }+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionAlter {+ sql, err := generateAlterTableForeignKeys(tableDiff)+ if err != nil {+ return err}- }-- // Add foreign keys for ALTER table operations after all tables are created- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionAlter {- // Only add foreign keys in this second pass- fkSQL, err := generateAlterTableForeignKeys(tableDiff)- if err != nil {- return err- }- _, _ = buf.WriteString(fkSQL)- if fkSQL != "" {- _, _ = buf.WriteString("\n")- }+ if sql != "" {+ _, _ = buf.WriteString(sql)+ _, _ = buf.WriteString("\n")}}+ }+ return nil+}- // Add triggers for ALTER table operations after foreign keys- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionAlter {- triggerSQL := generateAlterTableTriggers(tableDiff)- _, _ = buf.WriteString(triggerSQL)- if triggerSQL != "" {- _, _ = buf.WriteString("\n")- }+// createPostProcessing handles triggers, indexes, comments, and event triggers.+func createPostProcessing(buf *strings.Builder, diff *schema.MetadataDiff, maps *objectMaps) error {+ // ALTER triggers+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionAlter {+ sql := generateAlterTableTriggers(tableDiff)+ if sql != "" {+ _, _ = buf.WriteString(sql)+ _, _ = buf.WriteString("\n")}}+ }- // Create triggers for CREATE table operations that aren't in TriggerChanges- // This handles metadata mode where triggers are in NewTable.Triggers but not in TriggerChanges- for _, tableDiff := range tableMap {- if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewTable != nil {- // Only create triggers that weren't already created from TriggerChanges- triggersInChanges := make(map[string]bool)- for _, triggerDiff := range tableDiff.TriggerChanges {- if triggerDiff.Action == schema.MetadataDiffActionCreate {- triggersInChanges[triggerDiff.TriggerName] = true- }+ // CREATE triggers not in TriggerChanges+ for _, tableDiff := range maps.tables {+ if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewTable != nil {+ triggersInChanges := make(map[string]bool)+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionCreate {+ triggersInChanges[triggerDiff.TriggerName] = true}-- for _, trigger := range tableDiff.NewTable.Triggers {- // Skip if already created from TriggerChanges- if !triggersInChanges[trigger.Name] {- writeMigrationTrigger(buf, trigger)- }+ }+ for _, trigger := range tableDiff.NewTable.Triggers {+ if !triggersInChanges[trigger.Name] {+ writeMigrationTrigger(buf, trigger)}}}+ }- // Create indexes for materialized views after they are created- for _, mvDiff := range diff.MaterializedViewChanges {- if mvDiff.Action == schema.MetadataDiffActionCreate && mvDiff.NewMaterializedView != nil {- for _, index := range mvDiff.NewMaterializedView.Indexes {- writeMigrationMaterializedViewIndex(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView.Name, index)- }+ // MV indexes+ for _, mvDiff := range diff.MaterializedViewChanges {+ if mvDiff.Action == schema.MetadataDiffActionCreate && mvDiff.NewMaterializedView != nil {+ for _, index := range mvDiff.NewMaterializedView.Indexes {+ writeMigrationMaterializedViewIndex(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView.Name, index)}}-- // Add indexes for materialized view ALTER operations- for _, mvDiff := range diff.MaterializedViewChanges {- if mvDiff.Action == schema.MetadataDiffActionAlter {- for _, indexDiff := range mvDiff.IndexChanges {- if indexDiff.Action == schema.MetadataDiffActionCreate {- if indexDiff.NewIndex != nil {- // Metadata mode: use index metadata- writeMigrationMaterializedViewIndex(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName, indexDiff.NewIndex)- } else if indexDiff.NewASTNode != nil {- // AST-only mode: extract from AST node- if indexAST, ok := indexDiff.NewASTNode.(*pgparser.IndexstmtContext); ok {- if err := writeCreateIndexFromAST(buf, indexAST); err != nil {- // If AST extraction fails, log error but continue (non-fatal)- _, _ = fmt.Fprintf(buf, "-- Error creating index: %v\n", err)- }+ if mvDiff.Action == schema.MetadataDiffActionAlter {+ for _, indexDiff := range mvDiff.IndexChanges {+ if indexDiff.Action == schema.MetadataDiffActionCreate {+ if indexDiff.NewIndex != nil {+ writeMigrationMaterializedViewIndex(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName, indexDiff.NewIndex)+ } else if indexDiff.NewASTNode != nil {+ if indexAST, ok := indexDiff.NewASTNode.(*pgparser.IndexstmtContext); ok {+ if err := writeCreateIndexFromAST(buf, indexAST); err != nil {+ _, _ = fmt.Fprintf(buf, "-- Error creating index: %v\n", err)}}}@@ -1380,42 +1050,29 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}- // ALTER table operations are now handled earlier in the topological order+ // Commentsfor _, tableDiff := range diff.TableChanges {if tableDiff.Action == schema.MetadataDiffActionAlter {- // Handle table comment changesif err := generateTableCommentChanges(buf, tableDiff); err != nil {return err}-- // Handle column comment changesif err := generateColumnCommentChanges(buf, tableDiff); err != nil {return err}-- // Handle index comment changesif err := generateIndexCommentChanges(buf, tableDiff); err != nil {return err}}}-- // Handle schema comment changesif err := generateSchemaCommentChanges(buf, diff); err != nil {return err}-- // Handle view comment changesif err := generateViewCommentChanges(buf, diff); err != nil {return err}-- // Handle materialized view comment changesif err := generateMaterializedViewCommentChanges(buf, diff); err != nil {return err}-- // Handle materialized view index comment changesfor _, mvDiff := range diff.MaterializedViewChanges {if mvDiff.Action == schema.MetadataDiffActionAlter {if err := generateMaterializedViewIndexCommentChanges(buf, mvDiff); err != nil {@@ -1423,33 +1080,24 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}}-- // Handle function comment changesif err := generateFunctionCommentChanges(buf, diff); err != nil {return err}-- // Handle sequence comment changesif err := generateSequenceCommentChanges(buf, diff); err != nil {return err}-- // Handle sequence ownership changes (must be after all tables are created)if err := generateSequenceOwnershipChanges(buf, diff); err != nil {return err}- // Create event triggers (last, as they depend on functions which may have been created)+ // Event triggersfor _, etDiff := range diff.EventTriggerChanges {if etDiff.Action == schema.MetadataDiffActionCreate {- // Support both metadata and AST-only modesif etDiff.NewEventTrigger != nil {- // Metadata mode: use event trigger metadataif err := writeCreateEventTrigger(buf, etDiff.NewEventTrigger); err != nil {return err}} else if etDiff.NewASTNode != nil {- // AST-only mode: extract SQL from AST nodeif err := writeMigrationEventTriggerFromAST(buf, etDiff.NewASTNode); err != nil {return err}@@ -1457,15 +1105,59 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}- // Handle enum type comment changesif err := generateEnumTypeCommentChanges(buf, diff); err != nil {return err}-- // Handle SDL-based comment changes (from SDL diff mode)return generateCommentChangesFromSDL(buf, diff)}+// createObjectsInOrder creates all objects in topological order (dependencies first).+func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error {+ if err := createSchemas(diff, buf); err != nil {+ return err+ }+ if err := createExtensions(diff, buf); err != nil {+ return err+ }+ if err := createEnumTypes(diff, buf); err != nil {+ return err+ }+ if err := createSequences(diff, buf); err != nil {+ return err+ }++ maps := buildObjectMaps(diff)+ tempMetadata := buildTempMetadataForCreate(diff)++ hasFKCycle, err := createTables(buf, maps)+ if err != nil {+ return err+ }+ if err := alterTables(buf, maps); err != nil {+ return err+ }+ if err := createViewsMVsFunctions(buf, maps, tempMetadata); err != nil {+ return err+ }+ if err := createTriggers(buf, maps); err != nil {+ return err+ }++ // Set sequence ownership+ for _, seqDiff := range diff.SequenceChanges {+ if seqDiff.Action == schema.MetadataDiffActionCreate && seqDiff.NewSequence != nil && seqDiff.NewSequence.OwnerTable != "" && seqDiff.NewSequence.OwnerColumn != "" {+ if err := writeMigrationSequenceOwnership(buf, seqDiff.SchemaName, seqDiff.NewSequence); err != nil {+ return err+ }+ }+ }++ if err := addForeignKeys(buf, maps, hasFKCycle); err != nil {+ return err+ }+ return createPostProcessing(buf, diff, maps)+}+func generateCreateTable(schemaName, tableName string, table *storepb.TableMetadata, includeForeignKeys bool) (string, error) {var buf strings.Builder@@ -4770,6 +4462,179 @@ func writeAllForeignKeysFromTableAST(out *strings.Builder, schema, table string,}}+// writeViewDiff writes a view creation/alteration based on the diff.+func writeViewDiff(buf *strings.Builder, viewDiff *schema.ViewDiff) error {+ switch viewDiff.Action {+ case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:+ if viewDiff.NewView != nil {+ if err := writeMigrationView(buf, viewDiff.SchemaName, viewDiff.NewView); err != nil {+ return err+ }+ } else if viewDiff.NewASTNode != nil {+ if err := writeMigrationViewFromAST(buf, viewDiff.NewASTNode); err != nil {+ return err+ }+ } else {+ return errors.Errorf("view diff for %s.%s has neither metadata nor AST node", viewDiff.SchemaName, viewDiff.ViewName)+ }+ default:+ // Other actions (like Delete) are handled elsewhere+ }+ // Add view comment for newly created views+ if viewDiff.NewView != nil && viewDiff.NewView.Comment != "" {+ writeCommentOnView(buf, viewDiff.SchemaName, viewDiff.ViewName, viewDiff.NewView.Comment)+ }+ return nil+}++// writeMaterializedViewDiff writes a materialized view creation/alteration based on the diff.+func writeMaterializedViewDiff(buf *strings.Builder, mvDiff *schema.MaterializedViewDiff) error {+ switch mvDiff.Action {+ case schema.MetadataDiffActionCreate:+ // Support AST-only mode: if metadata is nil but AST node exists, use AST+ if mvDiff.NewMaterializedView != nil {+ if err := writeMigrationMaterializedView(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView); err != nil {+ return err+ }+ } else if mvDiff.NewASTNode != nil {+ if err := writeMigrationMaterializedViewFromAST(buf, mvDiff.NewASTNode); err != nil {+ return err+ }+ } else {+ return errors.Errorf("materialized view diff for %s.%s has neither metadata nor AST node", mvDiff.SchemaName, mvDiff.MaterializedViewName)+ }+ case schema.MetadataDiffActionAlter:+ // Check if this is an index-only change (no MV definition change)+ hasIndexOnlyChanges := len(mvDiff.IndexChanges) > 0 && mvDiff.NewMaterializedView == nil && mvDiff.NewASTNode == nil++ // For index-only changes, don't alter the MV itself+ // Index changes are processed separately later+ if !hasIndexOnlyChanges {+ // For PostgreSQL materialized views, we need to drop and recreate+ // since ALTER MATERIALIZED VIEW doesn't support changing the definition+ writeDropMaterializedView(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName)+ // Support AST-only mode+ if mvDiff.NewMaterializedView != nil {+ if err := writeMigrationMaterializedView(buf, mvDiff.SchemaName, mvDiff.NewMaterializedView); err != nil {+ return err+ }+ } else if mvDiff.NewASTNode != nil {+ if err := writeMigrationMaterializedViewFromAST(buf, mvDiff.NewASTNode); err != nil {+ return err+ }+ } else {+ return errors.Errorf("materialized view ALTER for %s.%s has neither metadata nor AST node", mvDiff.SchemaName, mvDiff.MaterializedViewName)+ }+ }+ default:+ // Other actions (like Delete) are handled elsewhere+ }+ // Add materialized view comment for newly created or altered materialized views+ if mvDiff.NewMaterializedView != nil && mvDiff.NewMaterializedView.Comment != "" {+ writeCommentOnMaterializedView(buf, mvDiff.SchemaName, mvDiff.MaterializedViewName, mvDiff.NewMaterializedView.Comment)+ }+ return nil+}++// writeCreateTableDiff creates a table based on the diff, optionally including FK.+func writeCreateTableDiff(buf *strings.Builder, tableDiff *schema.TableDiff, includeFK bool) error {+ if tableDiff.NewTable != nil {+ // Metadata mode: use generateCreateTable+ createTableSQL, err := generateCreateTable(tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable, includeFK)+ if err != nil {+ return err+ }+ _, _ = buf.WriteString(createTableSQL)+ if createTableSQL != "" {+ _, _ = buf.WriteString("\n")+ }++ // Add table and column comments for newly created tables+ if tableDiff.NewTable.Comment != "" {+ writeCommentOnTable(buf, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewTable.Comment)+ }+ for _, col := range tableDiff.NewTable.Columns {+ if col.Comment != "" {+ writeCommentOnColumn(buf, tableDiff.SchemaName, tableDiff.TableName, col.Name, col.Comment)+ }+ }+ } else if tableDiff.NewASTNode != nil {+ // AST-only mode+ if includeFK {+ if err := writeMigrationTableFromAST(buf, tableDiff.NewASTNode); err != nil {+ return err+ }+ } else {+ if err := writeMigrationTableFromASTWithoutFK(buf, tableDiff.NewASTNode); err != nil {+ return err+ }+ }+ } else {+ return errors.Errorf("table CREATE action requires either NewTable metadata or NewASTNode for table %s.%s", tableDiff.SchemaName, tableDiff.TableName)+ }+ return nil+}++// writeTableIndexesForCreate writes indexes for a newly created table.+func writeTableIndexesForCreate(buf *strings.Builder, tableDiff *schema.TableDiff) {+ for _, indexDiff := range tableDiff.IndexChanges {+ if indexDiff.Action == schema.MetadataDiffActionCreate {+ if indexDiff.NewIndex != nil {+ // Metadata mode: use index metadata+ if indexDiff.NewIndex.IsConstraint {+ // Skip constraint-based indexes (primary key, unique, exclude)+ // They are already included in CREATE TABLE statement+ continue+ }+ writeMigrationIndex(buf, tableDiff.SchemaName, tableDiff.TableName, indexDiff.NewIndex)+ } else if indexDiff.NewASTNode != nil {+ // AST-only mode: extract from AST node+ if indexAST, ok := indexDiff.NewASTNode.(*pgparser.IndexstmtContext); ok {+ if err := writeCreateIndexFromAST(buf, indexAST); err != nil {+ _, _ = fmt.Fprintf(buf, "-- Error creating index: %v\n", err)+ }+ }+ }+ }+ }+}++// writeTableForeignKeysForCreate writes foreign keys for a CREATE table operation.+func writeTableForeignKeysForCreate(buf *strings.Builder, tableDiff *schema.TableDiff) error {+ if tableDiff.NewTable != nil {+ // Metadata mode+ for _, fk := range tableDiff.NewTable.ForeignKeys {+ if err := writeMigrationForeignKey(buf, tableDiff.SchemaName, tableDiff.TableName, fk); err != nil {+ return err+ }+ }+ } else if tableDiff.NewASTNode != nil {+ // AST mode+ if len(tableDiff.ForeignKeyChanges) > 0 {+ // FKs are in ForeignKeyChanges+ for _, fkDiff := range tableDiff.ForeignKeyChanges {+ if fkDiff.Action == schema.MetadataDiffActionCreate {+ if fkDiff.NewForeignKey != nil {+ if err := writeMigrationForeignKey(buf, tableDiff.SchemaName, tableDiff.TableName, fkDiff.NewForeignKey); err != nil {+ return err+ }+ } else if fkDiff.NewASTNode != nil {+ if constraintAST, ok := fkDiff.NewASTNode.(pgparser.ITableconstraintContext); ok {+ if err := writeAddForeignKeyFromAST(buf, tableDiff.SchemaName, tableDiff.TableName, constraintAST); err != nil {+ _, _ = fmt.Fprintf(buf, "-- Error adding foreign key constraint: %v\n", err)+ }+ }+ }+ }+ }+ } else {+ // Pure AST mode - FKs are embedded in the AST node itself+ writeAllForeignKeysFromTableAST(buf, tableDiff.SchemaName, tableDiff.TableName, tableDiff.NewASTNode)+ }+ }+ return nil+}+// writeAddUniqueConstraintFromAST adds a unique constraint using AST nodefunc writeAddUniqueConstraintFromAST(out *strings.Builder, schema, table string, constraintAST pgparser.ITableconstraintContext) error {if constraintAST == nil {@@ -4978,12 +4843,6 @@ func extractForeignKeysFromAST(createStmt *pgparser.CreatestmtContext, defaultScreturn foreignKeys}-// getTriggerObjectID generates a unique identifier for trigger objects-// Triggers are table-scoped in PostgreSQL, so identifier is schema.table.trigger_name-func getTriggerObjectID(triggerDiff *schema.TriggerDiff) string {- return fmt.Sprintf("trigger:%s.%s.%s", triggerDiff.SchemaName, triggerDiff.TableName, triggerDiff.TriggerName)-}-// writeCreateTrigger writes a CREATE TRIGGER or CREATE OR REPLACE TRIGGER statementfunc writeCreateTrigger(buf *strings.Builder, triggerDiff *schema.TriggerDiff) error {switch triggerDiff.Action {@@ -5042,53 +4901,6 @@ func writeCreateTrigger(buf *strings.Builder, triggerDiff *schema.TriggerDiff) ereturn nil}-// extractTriggerFunctionName extracts the function name from EXECUTE FUNCTION clause-func extractTriggerFunctionName(astNode any) string {- triggerStmt, ok := astNode.(*pgparser.CreatetrigstmtContext)- if !ok || triggerStmt == nil {- return ""- }-- // Get text from token stream for more reliable parsing- var text string- if tokenStream := triggerStmt.GetParser().GetTokenStream(); tokenStream != nil {- start := triggerStmt.GetStart()- stop := triggerStmt.GetStop()- if start != nil && stop != nil {- text = tokenStream.GetTextFromTokens(start, stop)- }- }-- if text == "" {- text = triggerStmt.GetText()- }-- // Look for "EXECUTE FUNCTION function_name" or "EXECUTE PROCEDURE function_name"- upperText := strings.ToUpper(text)- idx := strings.Index(upperText, "EXECUTE FUNCTION")- if idx == -1 {- idx = strings.Index(upperText, "EXECUTE PROCEDURE")- if idx == -1 {- return ""- }- idx += len("EXECUTE PROCEDURE")- } else {- idx += len("EXECUTE FUNCTION")- }-- remaining := strings.TrimSpace(text[idx:])- // Extract function name (first word, possibly schema-qualified)- endIdx := strings.IndexAny(remaining, "();")- if endIdx > 0 {- funcName := strings.TrimSpace(remaining[:endIdx])- // Remove quotes if present- funcName = strings.Trim(funcName, "\"")- return funcName- }-- return ""-}-// convertTriggerToCreateOrReplace converts CREATE TRIGGER to CREATE OR REPLACE TRIGGER using ANTLRfunc convertTriggerToCreateOrReplace(definition string) string {// Parse the SQL statement using ANTLRdiff --git a/backend/tests/pg_sdl_rollout_test.go b/backend/tests/pg_sdl_rollout_test.goindex f7921e7df2..4f05395a59 100644--- a/backend/tests/pg_sdl_rollout_test.go+++ b/backend/tests/pg_sdl_rollout_test.go@@ -377,6 +377,28 @@ func (stc *sdlTestContext) verifyViewExists(t *testing.T, database *v1pb.Databasreturn false}+// verifyMaterializedViewExists checks if a materialized view exists in the database schema.+func (stc *sdlTestContext) verifyMaterializedViewExists(t *testing.T, database *v1pb.Database, mvName string) bool {+ t.Helper()+ a := require.New(t)++ metadata, err := stc.ctl.databaseServiceClient.GetDatabaseMetadata(stc.ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{+ Name: database.Name + "/metadata",+ }))+ a.NoError(err)++ for _, schema := range metadata.Msg.Schemas {+ if schema.Name == "public" {+ for _, mv := range schema.MaterializedViews {+ if mv.Name == mvName {+ return true+ }+ }+ }+ }+ return false+}+// verifyFunctionExists checks if a function exists in the database schema.func (stc *sdlTestContext) verifyFunctionExists(t *testing.T, database *v1pb.Database, functionName string) bool {t.Helper()@@ -1947,6 +1969,205 @@ CREATE TABLE "public"."namespaces" (a.True(stc.verifyForeignKeyExists(t, database, "public", "namespaces", "fk_namespaces_project"))a.True(stc.verifyForeignKeyExists(t, database, "public", "namespaces", "fk_namespaces_parent"))})++ t.Run("CyclicFKWithDependentViews", func(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ stc := setupSDLTestContext(t)+ defer stc.cleanup()++ database := stc.createTestPgDatabase(t, "fk_cycle_views")++ // Create tables with cyclic FK and views that depend on each other+ // The views are intentionally ordered wrong (v2 before v1)+ // to test that topological sorting works correctly even when table FK cycle exists+ sdl := `CREATE TABLE "public"."namespaces" (+ "id" bigserial,+ "name" text NOT NULL,+ "project_id" bigint,+ CONSTRAINT "namespaces_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_namespaces_project" FOREIGN KEY ("project_id") REFERENCES "public"."projects" ("id") ON DELETE SET NULL+);++CREATE TABLE "public"."projects" (+ "id" bigserial,+ "name" text NOT NULL,+ "namespace_id" bigint NOT NULL,+ CONSTRAINT "projects_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_projects_namespace" FOREIGN KEY ("namespace_id") REFERENCES "public"."namespaces" ("id") ON DELETE CASCADE+);++CREATE VIEW "public"."v2_project_summary" AS+SELECT p.id, p.name, n.name as namespace_name+FROM "public"."v1_active_projects" p+JOIN "public"."namespaces" n ON p.namespace_id = n.id;++CREATE VIEW "public"."v1_active_projects" AS+SELECT id, name, namespace_id FROM "public"."projects" WHERE name IS NOT NULL;`++ err := stc.executeSDLRollout(t, database, sdl)+ a.NoError(err)+ a.True(stc.verifyTableExists(t, database, "public", "namespaces"))+ a.True(stc.verifyTableExists(t, database, "public", "projects"))+ a.True(stc.verifyViewExists(t, database, "v1_active_projects"))+ a.True(stc.verifyViewExists(t, database, "v2_project_summary"))+ // Verify FK constraints were created+ a.True(stc.verifyForeignKeyExists(t, database, "public", "namespaces", "fk_namespaces_project"))+ a.True(stc.verifyForeignKeyExists(t, database, "public", "projects", "fk_projects_namespace"))+ })++ t.Run("CyclicFKWithMaterializedViewChain", func(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ stc := setupSDLTestContext(t)+ defer stc.cleanup()++ database := stc.createTestPgDatabase(t, "fk_cycle_mv")++ // Create tables with cyclic FK and materialized views with dependencies+ // mv2 depends on mv1, and both depend on tables with FK cycle+ sdl := `CREATE TABLE "public"."orders" (+ "id" bigserial,+ "customer_id" bigint,+ "total" numeric(10, 2),+ CONSTRAINT "orders_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_orders_customer" FOREIGN KEY ("customer_id") REFERENCES "public"."customers" ("id") ON DELETE SET NULL+);++CREATE TABLE "public"."customers" (+ "id" bigserial,+ "name" text NOT NULL,+ "last_order_id" bigint,+ CONSTRAINT "customers_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_customers_last_order" FOREIGN KEY ("last_order_id") REFERENCES "public"."orders" ("id") ON DELETE SET NULL+);++CREATE MATERIALIZED VIEW "public"."mv2_customer_order_summary" AS+SELECT c.id, c.name, o.order_count, o.total_amount+FROM "public"."mv1_order_stats" o+JOIN "public"."customers" c ON o.customer_id = c.id;++CREATE MATERIALIZED VIEW "public"."mv1_order_stats" AS+SELECT customer_id, COUNT(*) as order_count, SUM(total) as total_amount+FROM "public"."orders"+GROUP BY customer_id;`++ err := stc.executeSDLRollout(t, database, sdl)+ a.NoError(err)+ a.True(stc.verifyTableExists(t, database, "public", "orders"))+ a.True(stc.verifyTableExists(t, database, "public", "customers"))+ a.True(stc.verifyMaterializedViewExists(t, database, "mv1_order_stats"))+ a.True(stc.verifyMaterializedViewExists(t, database, "mv2_customer_order_summary"))+ // Verify FK constraints were created+ a.True(stc.verifyForeignKeyExists(t, database, "public", "orders", "fk_orders_customer"))+ a.True(stc.verifyForeignKeyExists(t, database, "public", "customers", "fk_customers_last_order"))+ })++ t.Run("CyclicFKWithLongViewChain", func(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ stc := setupSDLTestContext(t)+ defer stc.cleanup()++ database := stc.createTestPgDatabase(t, "fk_cycle_view_chain")++ // Create tables with cyclic FK and a long chain of views: v4 -> v3 -> v2 -> v1+ // Views are intentionally defined in reverse order to test topological sorting+ sdl := `CREATE TABLE "public"."departments" (+ "id" bigserial,+ "name" text NOT NULL,+ "manager_id" bigint,+ CONSTRAINT "departments_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_dept_manager" FOREIGN KEY ("manager_id") REFERENCES "public"."employees" ("id") ON DELETE SET NULL+);++CREATE TABLE "public"."employees" (+ "id" bigserial,+ "name" text NOT NULL,+ "department_id" bigint,+ "salary" numeric(10, 2),+ CONSTRAINT "employees_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_emp_dept" FOREIGN KEY ("department_id") REFERENCES "public"."departments" ("id") ON DELETE SET NULL+);++CREATE VIEW "public"."v4_top_departments" AS+SELECT department_name, avg_salary FROM "public"."v3_dept_summary" WHERE avg_salary > 50000;++CREATE VIEW "public"."v3_dept_summary" AS+SELECT department_name, AVG(salary) as avg_salary FROM "public"."v2_employee_details" GROUP BY department_name;++CREATE VIEW "public"."v2_employee_details" AS+SELECT e.id, e.name, e.salary, d.name as department_name+FROM "public"."v1_active_employees" e+JOIN "public"."departments" d ON e.department_id = d.id;++CREATE VIEW "public"."v1_active_employees" AS+SELECT id, name, department_id, salary FROM "public"."employees" WHERE salary > 0;`++ err := stc.executeSDLRollout(t, database, sdl)+ a.NoError(err)+ a.True(stc.verifyTableExists(t, database, "public", "departments"))+ a.True(stc.verifyTableExists(t, database, "public", "employees"))+ a.True(stc.verifyViewExists(t, database, "v1_active_employees"))+ a.True(stc.verifyViewExists(t, database, "v2_employee_details"))+ a.True(stc.verifyViewExists(t, database, "v3_dept_summary"))+ a.True(stc.verifyViewExists(t, database, "v4_top_departments"))+ // Verify FK constraints were created+ a.True(stc.verifyForeignKeyExists(t, database, "public", "departments", "fk_dept_manager"))+ a.True(stc.verifyForeignKeyExists(t, database, "public", "employees", "fk_emp_dept"))+ })++ t.Run("CyclicFKWithMixedViewsAndMaterializedViews", func(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ stc := setupSDLTestContext(t)+ defer stc.cleanup()++ database := stc.createTestPgDatabase(t, "fk_cycle_mixed")++ // Create tables with cyclic FK and mixed views/materialized views with dependencies+ // mv depends on view, view depends on another view+ sdl := `CREATE TABLE "public"."products" (+ "id" bigserial,+ "name" text NOT NULL,+ "category_id" bigint,+ "price" numeric(10, 2),+ CONSTRAINT "products_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_prod_cat" FOREIGN KEY ("category_id") REFERENCES "public"."categories" ("id") ON DELETE SET NULL+);++CREATE TABLE "public"."categories" (+ "id" bigserial,+ "name" text NOT NULL,+ "featured_product_id" bigint,+ CONSTRAINT "categories_pkey" PRIMARY KEY (id),+ CONSTRAINT "fk_cat_featured" FOREIGN KEY ("featured_product_id") REFERENCES "public"."products" ("id") ON DELETE SET NULL+);++CREATE MATERIALIZED VIEW "public"."mv_category_stats" AS+SELECT category_name, product_count, avg_price+FROM "public"."v2_category_products";++CREATE VIEW "public"."v2_category_products" AS+SELECT c.name as category_name, COUNT(*) as product_count, AVG(p.price) as avg_price+FROM "public"."v1_available_products" p+JOIN "public"."categories" c ON p.category_id = c.id+GROUP BY c.name;++CREATE VIEW "public"."v1_available_products" AS+SELECT id, name, category_id, price FROM "public"."products" WHERE price > 0;`++ err := stc.executeSDLRollout(t, database, sdl)+ a.NoError(err)+ a.True(stc.verifyTableExists(t, database, "public", "products"))+ a.True(stc.verifyTableExists(t, database, "public", "categories"))+ a.True(stc.verifyViewExists(t, database, "v1_available_products"))+ a.True(stc.verifyViewExists(t, database, "v2_category_products"))+ a.True(stc.verifyMaterializedViewExists(t, database, "mv_category_stats"))+ // Verify FK constraints were created+ a.True(stc.verifyForeignKeyExists(t, database, "public", "products", "fk_prod_cat"))+ a.True(stc.verifyForeignKeyExists(t, database, "public", "categories", "fk_cat_featured"))+ })})// -------------------- ViewTable --------------------