Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: add PostgreSQL trigger support for SDL mode (#18130)
rebelice5231e700e5ac
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.goindex 7c11d1e48f..d6726ae152 100644--- a/backend/plugin/schema/differ.go+++ b/backend/plugin/schema/differ.go@@ -164,9 +164,14 @@ type UniqueConstraintDiff struct {// TriggerDiff represents changes to a trigger.type TriggerDiff struct {- Action MetadataDiffAction- OldTrigger *storepb.TriggerMetadata- NewTrigger *storepb.TriggerMetadata+ Action MetadataDiffAction+ SchemaName string // Schema name of the table that owns the trigger+ TableName string // Table name that owns the trigger+ TriggerName string // Trigger name+ OldTrigger *storepb.TriggerMetadata+ NewTrigger *storepb.TriggerMetadata+ OldASTNode any // AST node for old trigger (*parser.CreatetrigstmtContext)+ NewASTNode any // AST node for new trigger (*parser.CreatetrigstmtContext)}// PartitionDiff represents changes to table partitions.@@ -280,6 +285,7 @@ const (CommentObjectTypeFunction CommentObjectType = "FUNCTION"CommentObjectTypeSequence CommentObjectType = "SEQUENCE"CommentObjectTypeIndex CommentObjectType = "INDEX"+ CommentObjectTypeTrigger CommentObjectType = "TRIGGER"CommentObjectTypeType CommentObjectType = "TYPE"CommentObjectTypeExtension CommentObjectType = "EXTENSION")@@ -290,6 +296,7 @@ type CommentDiff struct {Action MetadataDiffAction // CREATE or ALTER (no DROP since object deletion removes comments automatically)ObjectType CommentObjectTypeSchemaName string+ TableName string // used for TRIGGER comments (COMMENT ON TRIGGER trigger_name ON table_name)ObjectName string // table/view/function/sequence/index nameColumnName string // only used for COLUMN commentsIndexName string // only used for table-level INDEX comments@@ -1396,8 +1403,9 @@ func compareTriggers(oldTriggers, newTriggers []*storepb.TriggerMetadata) []*Trifor triggerName, oldTrigger := range oldTriggerMap {if _, exists := newTriggerMap[triggerName]; !exists {changes = append(changes, &TriggerDiff{- Action: MetadataDiffActionDrop,- OldTrigger: oldTrigger,+ Action: MetadataDiffActionDrop,+ TriggerName: triggerName,+ OldTrigger: oldTrigger,})}}@@ -1407,18 +1415,21 @@ func compareTriggers(oldTriggers, newTriggers []*storepb.TriggerMetadata) []*TrioldTrigger, exists := oldTriggerMap[triggerName]if !exists {changes = append(changes, &TriggerDiff{- Action: MetadataDiffActionCreate,- NewTrigger: newTrigger,+ Action: MetadataDiffActionCreate,+ TriggerName: triggerName,+ NewTrigger: newTrigger,})} else if !triggersEqual(oldTrigger, newTrigger) {// Drop and recreate the trigger instead of alteringchanges = append(changes, &TriggerDiff{- Action: MetadataDiffActionDrop,- OldTrigger: oldTrigger,+ Action: MetadataDiffActionDrop,+ TriggerName: triggerName,+ OldTrigger: oldTrigger,})changes = append(changes, &TriggerDiff{- Action: MetadataDiffActionCreate,- NewTrigger: newTrigger,+ Action: MetadataDiffActionCreate,+ TriggerName: triggerName,+ NewTrigger: newTrigger,})}}diff --git a/backend/plugin/schema/pg/generate_migration.go b/backend/plugin/schema/pg/generate_migration.goindex 904fba3fa3..081e5857ce 100644--- a/backend/plugin/schema/pg/generate_migration.go+++ b/backend/plugin/schema/pg/generate_migration.go@@ -61,18 +61,32 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {}}- // Drop triggers that might depend on functions being dropped- // This includes triggers from tables being dropped AND from tables being altered+ // Drop all triggers first (before dropping functions or tables they depend on)+ // This avoids dependency errors when dropping functions or tablesfor _, tableDiff := range diff.TableChanges {- if tableDiff.OldTable != nil {+ // Use TriggerChanges for AST-only mode, OldTable.Triggers for metadata mode+ if len(tableDiff.TriggerChanges) > 0 {+ // AST-only mode: use TriggerChanges+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop {+ writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.TriggerName)+ }+ }+ } else if tableDiff.OldTable != nil && tableDiff.Action == schema.MetadataDiffActionDrop {+ // Metadata mode: use OldTable.Triggers+ // Only drop triggers for tables being droppedfor _, trigger := range tableDiff.OldTable.Triggers {- // Check if trigger body references any function being dropped- triggerBody := strings.ToLower(trigger.Body)- for funcName := range functionsBeingDropped {- if strings.Contains(triggerBody, funcName) {- writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, trigger.Name)- break- }+ writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, trigger.Name)+ }+ }+ }++ // Also drop triggers for ALTER table operations+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.Action == schema.MetadataDiffActionAlter {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop {+ writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.TriggerName)}}}@@ -248,14 +262,8 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {}}- // Drop triggers- for _, tableDiff := range diff.TableChanges {- if tableDiff.Action == schema.MetadataDiffActionDrop && tableDiff.OldTable != nil {- for _, trigger := range tableDiff.OldTable.Triggers {- writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, trigger.Name)- }- }- }+ // Triggers have already been dropped at the beginning of generateDrops function+ // to avoid dependency errors with functions and tables// Drop foreign keys from tables being droppedfor _, tableDiff := range diff.TableChanges {@@ -294,6 +302,17 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {// Handle remaining ALTER table operations (constraints, indexes, columns)for _, tableDiff := range diff.TableChanges {if tableDiff.Action == schema.MetadataDiffActionAlter {+ // Drop triggers+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop {+ // Skip triggers with empty names (defensive check)+ if triggerDiff.TriggerName == "" {+ continue+ }+ writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.TriggerName)+ }+ }+// Drop check constraintsfor _, checkDiff := range tableDiff.CheckConstraintChanges {if checkDiff.Action == schema.MetadataDiffActionDrop {@@ -378,14 +397,8 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {}// Drop in topological order (most dependent first)+ // Note: Triggers have already been dropped at the beginning of generateDropsfor _, objID := range orderedList {- // Drop triggers for tables being dropped- if tableDiff, ok := tableMap[objID]; ok && tableDiff.OldTable != nil {- for _, trigger := range tableDiff.OldTable.Triggers {- writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, trigger.Name)- }- }-// Drop the object itselfif viewDiff, ok := viewMap[objID]; ok {if viewDiff.Action == schema.MetadataDiffActionDrop {@@ -412,6 +425,17 @@ func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {// Handle remaining ALTER table drops (constraints, indexes, columns)for _, tableDiff := range diff.TableChanges {if tableDiff.Action == schema.MetadataDiffActionAlter {+ // Drop triggers+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop {+ // Skip triggers with empty names (defensive check)+ if triggerDiff.TriggerName == "" {+ continue+ }+ writeDropTrigger(buf, tableDiff.SchemaName, tableDiff.TableName, triggerDiff.TriggerName)+ }+ }+// Drop check constraintsfor _, checkDiff := range tableDiff.CheckConstraintChanges {if checkDiff.Action == schema.MetadataDiffActionDrop {@@ -751,6 +775,24 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}+ // 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+ }+ }+ }+ }+// 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@@ -832,6 +874,33 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}+ // 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 {@@ -1086,6 +1155,13 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) errorif (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 {+ if err := writeCreateTrigger(buf, triggerDiff); err != nil {+ return err+ }+ }}}@@ -1135,11 +1211,23 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error}}- // Create triggers after foreign keys (only for CREATE table operations)+ // Create triggers for CREATE table operations that aren't in TriggerChanges+ // This handles metadata mode where triggers are in NewTable.Triggers but not in TriggerChangesfor _, 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+ }+ }+for _, trigger := range tableDiff.NewTable.Triggers {- writeMigrationTrigger(buf, trigger)+ // Skip if already created from TriggerChanges+ if !triggersInChanges[trigger.Name] {+ writeMigrationTrigger(buf, trigger)+ }}}}@@ -1439,8 +1527,14 @@ func generateAlterTableTriggers(tableDiff *schema.TableDiff) string {var buf strings.Builderfor _, triggerDiff := range tableDiff.TriggerChanges {- if triggerDiff.Action == schema.MetadataDiffActionCreate {- writeMigrationTrigger(&buf, triggerDiff.NewTrigger)+ if triggerDiff.Action == schema.MetadataDiffActionCreate || triggerDiff.Action == schema.MetadataDiffActionAlter {+ // Use writeCreateTrigger which supports both AST and metadata modes+ // Both CREATE and ALTER use CREATE OR REPLACE+ if err := writeCreateTrigger(&buf, triggerDiff); err != nil {+ // Log error but continue - this is a best-effort operation+ // The error will be caught in the caller if needed+ continue+ }}}@@ -3500,6 +3594,36 @@ func writeCommentOnExtension(out *strings.Builder, extensionName, comment string_, _ = out.WriteString("\n")}+func writeCommentOnTrigger(out *strings.Builder, schemaName, tableName, triggerName, comment string) {+ // Parse table name to get schema and table separately+ parts := strings.Split(tableName, ".")+ var tableSchemaName, tableNameOnly string+ if len(parts) == 2 {+ tableSchemaName, tableNameOnly = parts[0], parts[1]+ } else {+ tableSchemaName, tableNameOnly = schemaName, tableName+ }++ _, _ = out.WriteString(`COMMENT ON TRIGGER "`)+ _, _ = out.WriteString(triggerName)+ _, _ = out.WriteString(`" ON "`)+ _, _ = out.WriteString(tableSchemaName)+ _, _ = out.WriteString(`"."`)+ _, _ = out.WriteString(tableNameOnly)+ _, _ = out.WriteString(`" IS `)+ if comment == "" {+ _, _ = out.WriteString(`NULL`)+ } else {+ _, _ = out.WriteString(`'`)+ // Escape single quotes in the comment+ escapedComment := strings.ReplaceAll(comment, "'", "''")+ _, _ = out.WriteString(escapedComment)+ _, _ = out.WriteString(`'`)+ }+ _, _ = out.WriteString(`;`)+ _, _ = out.WriteString("\n")+}+// generateCommentChangesFromSDL generates COMMENT ON statements from SDL-based comment diffs// This handles comment changes detected from SDL diff mode (AST-based)func generateCommentChangesFromSDL(buf *strings.Builder, diff *schema.MetadataDiff) error {@@ -3629,6 +3753,10 @@ func generateCommentChangesFromSDL(buf *strings.Builder, diff *schema.MetadataDi// COMMENT ON EXTENSIONwriteCommentOnExtension(buf, commentDiff.ObjectName, newComment)+ case schema.CommentObjectTypeTrigger:+ // COMMENT ON TRIGGER trigger_name ON table_name+ writeCommentOnTrigger(buf, commentDiff.SchemaName, commentDiff.TableName, commentDiff.ObjectName, newComment)+default:// Unknown object type, skipcontinue@@ -4412,3 +4540,261 @@ 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 statement+func writeCreateTrigger(buf *strings.Builder, triggerDiff *schema.TriggerDiff) error {+ switch triggerDiff.Action {+ case schema.MetadataDiffActionCreate, schema.MetadataDiffActionAlter:+ // For both CREATE and ALTER, use CREATE OR REPLACE TRIGGER+ if triggerDiff.NewASTNode != nil {+ // AST mode: extract SQL from AST node+ triggerStmt, ok := triggerDiff.NewASTNode.(*pgparser.CreatetrigstmtContext)+ if !ok {+ return errors.New("invalid AST node type for trigger")+ }++ // Extract SQL from token stream+ var sqlText string+ if tokenStream := triggerStmt.GetParser().GetTokenStream(); tokenStream != nil {+ start := triggerStmt.GetStart()+ stop := triggerStmt.GetStop()+ if start != nil && stop != nil {+ sqlText = tokenStream.GetTextFromTokens(start, stop)+ }+ }++ if sqlText == "" {+ sqlText = triggerStmt.GetText()+ }++ // Convert to CREATE OR REPLACE for idempotency+ sqlText = convertTriggerToCreateOrReplace(sqlText)++ sqlText = strings.TrimSpace(sqlText)+ if !strings.HasSuffix(sqlText, ";") {+ sqlText += ";"+ }++ buf.WriteString(sqlText)+ buf.WriteString("\n\n")++ return nil+ } else if triggerDiff.NewTrigger != nil {+ // Metadata mode: convert trigger body to CREATE OR REPLACE+ triggerSQL := convertTriggerToCreateOrReplace(triggerDiff.NewTrigger.Body)+ buf.WriteString(triggerSQL)+ if !strings.HasSuffix(strings.TrimSpace(triggerSQL), ";") {+ buf.WriteString(";")+ }+ buf.WriteString("\n\n")+ return nil+ }++ return errors.Errorf("trigger %s requires either NewASTNode or NewTrigger", triggerDiff.Action)++ default:+ // Ignore other actions like DROP (handled elsewhere)+ }++ return 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 ANTLR+func convertTriggerToCreateOrReplace(definition string) string {+ // Parse the SQL statement using ANTLR+ inputStream := antlr.NewInputStream(definition)+ lexer := pgparser.NewPostgreSQLLexer(inputStream)+ stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)+ parser := pgparser.NewPostgreSQLParser(stream)++ // Parse the root+ tree := parser.Root()+ if tree == nil {+ // If parsing fails, return original definition+ return definition+ }++ // Create a visitor to find and modify CREATE TRIGGER statements+ visitor := &CreateOrReplaceTriggerVisitor{+ tokens: stream,+ rewriter: antlr.NewTokenStreamRewriter(stream),+ definition: definition,+ }++ // Visit the tree+ visitor.Visit(tree)++ // Get the modified text+ interval := antlr.NewInterval(0, len(definition)-1)+ result := visitor.rewriter.GetText("", interval)+ if result == "" {+ // If rewriting fails, return original definition+ return definition+ }++ return result+}++// CreateOrReplaceTriggerVisitor visits the parse tree and modifies CREATE TRIGGER to CREATE OR REPLACE TRIGGER+type CreateOrReplaceTriggerVisitor struct {+ *pgparser.BasePostgreSQLParserVisitor+ tokens *antlr.CommonTokenStream+ rewriter *antlr.TokenStreamRewriter+ definition string+}++// Visit implements the visitor pattern+func (v *CreateOrReplaceTriggerVisitor) Visit(tree antlr.ParseTree) any {+ switch t := tree.(type) {+ case *pgparser.CreatetrigstmtContext:+ return v.visitCreateTriggerStmt(t)+ default:+ // Continue visiting children+ return v.visitChildren(tree)+ }+}++// visitChildren visits all children of a node+func (v *CreateOrReplaceTriggerVisitor) visitChildren(node antlr.ParseTree) any {+ for i := 0; i < node.GetChildCount(); i++ {+ child := node.GetChild(i)+ if parseTree, ok := child.(antlr.ParseTree); ok {+ v.Visit(parseTree)+ }+ }+ return nil+}++// visitCreateTriggerStmt handles CREATE TRIGGER statements+func (v *CreateOrReplaceTriggerVisitor) visitCreateTriggerStmt(ctx *pgparser.CreatetrigstmtContext) any {+ if ctx == nil {+ return nil+ }++ // Check if "OR REPLACE" already exists+ if v.hasOrReplace(ctx) {+ // Already has "OR REPLACE", no need to modify+ return nil+ }++ // Find the CREATE token+ createToken := ctx.GetStart()+ if createToken == nil {+ return nil+ }++ // Look for the TRIGGER keyword after CREATE+ triggerToken := v.findTriggerToken(ctx)+ if triggerToken == nil {+ return nil+ }++ // Insert "OR REPLACE" between CREATE and TRIGGER+ // We insert it right before the TRIGGER token+ v.rewriter.InsertBefore("", triggerToken.GetTokenIndex(), "OR REPLACE ")++ return nil+}++// findTriggerToken finds the TRIGGER token in the CREATE TRIGGER statement+func (v *CreateOrReplaceTriggerVisitor) findTriggerToken(ctx *pgparser.CreatetrigstmtContext) antlr.Token {+ // Get all tokens in the context range+ start := ctx.GetStart().GetTokenIndex()+ stop := ctx.GetStop().GetTokenIndex()++ for i := start; i <= stop; i++ {+ token := v.tokens.Get(i)+ if token.GetTokenType() == pgparser.PostgreSQLParserTRIGGER {+ return token+ }+ }++ return nil+}++// hasOrReplace checks if the CREATE TRIGGER statement already contains "OR REPLACE"+func (v *CreateOrReplaceTriggerVisitor) hasOrReplace(ctx *pgparser.CreatetrigstmtContext) bool {+ // Get all tokens in the context range between CREATE and TRIGGER+ start := ctx.GetStart().GetTokenIndex()+ triggerToken := v.findTriggerToken(ctx)+ if triggerToken == nil {+ return false+ }+ stop := triggerToken.GetTokenIndex()++ // Look for "OR" followed by "REPLACE" tokens, skipping whitespace+ for i := start; i < stop; i++ {+ token := v.tokens.Get(i)+ if token.GetTokenType() == pgparser.PostgreSQLParserOR {+ // Found OR, now look for REPLACE after it (skipping whitespace)+ for j := i + 1; j < stop; j++ {+ nextToken := v.tokens.Get(j)+ // Skip whitespace tokens (channel 1 is hidden channel)+ if nextToken.GetChannel() == 1 {+ continue+ }+ // Check if the next non-whitespace token is REPLACE+ if nextToken.GetTokenType() == pgparser.PostgreSQLParserREPLACE {+ return true+ }+ // If it's not REPLACE, this OR is not our OR REPLACE pattern+ break+ }+ }+ }++ return false+}diff --git a/backend/plugin/schema/pg/get_database_definition.go b/backend/plugin/schema/pg/get_database_definition.goindex ac027266d7..63e4c8ff60 100644--- a/backend/plugin/schema/pg/get_database_definition.go+++ b/backend/plugin/schema/pg/get_database_definition.go@@ -2475,6 +2475,20 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {}}}++ // Write CREATE TRIGGER statements+ if err := writeTriggersSDL(&buf, schema.Name, table); err != nil {+ 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 ALTER SEQUENCE OWNED BY statements for sequences that have owners@@ -3425,6 +3439,20 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s}}+ // Write CREATE TRIGGER statements+ if err := writeTriggersSDL(&buf, schemaName, table); err != nil {+ 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 owned sequences (non-serial/non-identity) for this tablefor _, sequence := range tableSequences {// Skip sequences that belong to serial or identity columns@@ -3942,3 +3970,64 @@ func writeIndexCommentSDL(out io.Writer, schemaName string, index *storepb.Index_, err := io.WriteString(out, "\n\n")return err}++func writeTriggersSDL(out io.Writer, schemaName string, table *storepb.TableMetadata) error {+ for _, trigger := range table.Triggers {+ if trigger.SkipDump {+ continue+ }++ if err := writeTriggerSDL(out, schemaName, table.Name, trigger); err != nil {+ return err+ }++ if _, err := io.WriteString(out, ";\n\n"); err != nil {+ return err+ }+ }+ return nil+}++func writeTriggerSDL(out io.Writer, _ /* schemaName */, _ /* tableName */ string, trigger *storepb.TriggerMetadata) error {+ // For PostgreSQL, trigger.Body contains the complete CREATE TRIGGER statement+ // built by buildTriggerDefinition in get_database_metadata.go+ _, err := io.WriteString(out, trigger.Body)+ return err+}++func writeTriggerCommentSDL(out io.Writer, schemaName, tableName string, trigger *storepb.TriggerMetadata) error {+ if len(trigger.Comment) == 0 {+ return nil+ }++ if _, err := io.WriteString(out, `COMMENT ON TRIGGER "`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, trigger.Name); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `" ON "`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, schemaName); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `"."`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, tableName); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `" IS '`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, escapeSingleQuote(trigger.Comment)); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `';`); err != nil {+ return err+ }++ _, err := io.WriteString(out, "\n\n")+ return err+}diff --git a/backend/plugin/schema/pg/get_sdl_diff.go b/backend/plugin/schema/pg/get_sdl_diff.goindex 509ee4ccf5..fd25368ea7 100644--- a/backend/plugin/schema/pg/get_sdl_diff.go+++ b/backend/plugin/schema/pg/get_sdl_diff.go@@ -88,6 +88,9 @@ func GetSDLDiff(currentSDLText, previousUserSDLText string, currentSchema, previ// Process index changes (standalone CREATE INDEX statements)processStandaloneIndexChanges(currentChunks, previousChunks, currentDBSDLChunks, diff)+ // Process trigger changes (standalone CREATE TRIGGER statements)+ processStandaloneTriggerChanges(currentChunks, previousChunks, currentDBSDLChunks, diff)+// Process view changesprocessViewChanges(currentChunks, previousChunks, currentDBSDLChunks, diff)@@ -126,6 +129,7 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {Views: make(map[string]*schema.SDLChunk),MaterializedViews: make(map[string]*schema.SDLChunk),Functions: make(map[string]*schema.SDLChunk),+ Triggers: make(map[string]*schema.SDLChunk),Indexes: make(map[string]*schema.SDLChunk),Sequences: make(map[string]*schema.SDLChunk),Schemas: make(map[string]*schema.SDLChunk),@@ -148,6 +152,7 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {Views: make(map[string]*schema.SDLChunk),MaterializedViews: make(map[string]*schema.SDLChunk),Functions: make(map[string]*schema.SDLChunk),+ Triggers: make(map[string]*schema.SDLChunk),Indexes: make(map[string]*schema.SDLChunk),Sequences: make(map[string]*schema.SDLChunk),Schemas: make(map[string]*schema.SDLChunk),@@ -361,6 +366,48 @@ func (l *sdlChunkExtractor) EnterIndexstmt(ctx *parser.IndexstmtContext) {l.chunks.Indexes[schemaQualifiedName] = chunk}+// EnterCreatetrigstmt handles CREATE TRIGGER statements+func (l *sdlChunkExtractor) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {+ // Check if this is CREATE TRIGGER+ if ctx.CREATE() == nil || ctx.TRIGGER() == nil {+ return+ }++ // Extract trigger name+ if ctx.Name() == nil {+ return+ }+ triggerName := pgparser.NormalizePostgreSQLName(ctx.Name())++ // Extract table name from ON clause+ tableName := extractTableNameFromTrigger(ctx)+ if tableName == "" {+ return+ }++ // Parse schema and table from table name (format: schema.table)+ parts := strings.Split(tableName, ".")+ var schemaName string+ var unqualifiedTableName string+ if len(parts) == 2 {+ schemaName = parts[0]+ unqualifiedTableName = parts[1]+ } else {+ schemaName = "public"+ unqualifiedTableName = tableName+ }++ // Create identifier: schema.table.trigger_name (table-scoped)+ schemaQualifiedName := schemaName + "." + unqualifiedTableName + "." + triggerName++ chunk := &schema.SDLChunk{+ Identifier: schemaQualifiedName,+ ASTNode: ctx,+ }++ l.chunks.Triggers[schemaQualifiedName] = chunk+}+func (l *sdlChunkExtractor) EnterViewstmt(ctx *parser.ViewstmtContext) {if ctx.Qualified_name() == nil {return@@ -706,6 +753,64 @@ func (l *sdlChunkExtractor) EnterCommentstmt(ctx *parser.CommentstmtContext) {return}+ // Handle: COMMENT ON TRIGGER trigger_name ON table_name IS 'comment'+ if ctx.Object_type_name_on_any_name() != nil {+ objectType := ctx.Object_type_name_on_any_name().GetText()+ if strings.ToUpper(objectType) == "TRIGGER" {+ // Extract trigger name+ if ctx.Name() == nil {+ return+ }+ triggerName := pgparser.NormalizePostgreSQLName(ctx.Name())++ // Extract table name from Any_name+ if ctx.Any_name() == nil {+ return+ }+ anyName := pgparser.NormalizePostgreSQLAnyName(ctx.Any_name())+ if len(anyName) == 0 {+ return+ }++ // Build fully qualified table name+ var tableName string+ var unqualifiedTableName string+ if len(anyName) >= 2 {+ // schema.table+ tableName = strings.Join(anyName, ".")+ unqualifiedTableName = anyName[1]+ } else {+ // table (default to public schema)+ tableName = "public." + anyName[0]+ unqualifiedTableName = anyName[0]+ }++ // Parse schema from table name+ parts := strings.Split(tableName, ".")+ var schemaName string+ if len(parts) == 2 {+ schemaName = parts[0]+ } else {+ schemaName = "public"+ }++ // Use table-scoped identifier: schema.table.trigger_name+ // This matches the identifier format in EnterCreatetrigstmt+ identifier := schemaName + "." + unqualifiedTableName + "." + triggerName++ if chunk, exists := l.chunks.Triggers[identifier]; exists {+ chunk.CommentStatements = append(chunk.CommentStatements, ctx)+ } else {+ chunk := &schema.SDLChunk{+ Identifier: identifier,+ ASTNode: nil,+ CommentStatements: []antlr.ParserRuleContext{ctx},+ }+ l.chunks.Triggers[identifier] = chunk+ }+ }+ }+// Check for object_type_name_on_any_name: TRIGGER, RULE, POLICY (we don't track these currently)// These are table-level objects that we may want to support in the future}@@ -2781,6 +2886,12 @@ func applyMinimalChangesToChunks(previousChunks *schema.SDLChunks, currentSchemareturn errors.Wrap(err, "failed to apply extension changes")}+ // Process trigger changes: apply minimal changes to trigger chunks+ err = applyTriggerChangesToChunks(previousChunks, currentSchema, previousSchema)+ if err != nil {+ return errors.Wrap(err, "failed to apply trigger changes")+ }+// Process column comment changes: sync column comments based on metadataerr = applyColumnCommentChanges(previousChunks, currentSchema, previousSchema)if err != nil {@@ -7110,3 +7221,311 @@ func extensionsEqual(a, b *storepb.ExtensionMetadata) bool {a.Version == b.Version &&a.Description == b.Description}++// extractTableNameFromTrigger extracts the fully qualified table name from CREATE TRIGGER ... ON table+// Returns schema.table format, defaulting to public schema if not specified+func extractTableNameFromTrigger(ctx *parser.CreatetrigstmtContext) string {+ if ctx == nil {+ return ""+ }++ // Find ON clause - the table name comes after ON keyword+ // In PostgreSQL grammar: CREATE TRIGGER name ... ON qualified_name+ if ctx.Qualified_name() == nil {+ return ""+ }++ // Extract table name+ qualifiedNameParts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())+ if len(qualifiedNameParts) == 0 {+ return ""+ }++ // Return fully qualified name (schema.table)+ if len(qualifiedNameParts) == 1 {+ // No schema specified, default to public+ return "public." + qualifiedNameParts[0]+ }+ // Schema is specified+ return strings.Join(qualifiedNameParts, ".")+}++// applyTriggerChangesToChunks applies minimal changes to trigger chunks based on schema metadata+func applyTriggerChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {+ if currentSchema == nil || previousSchema == nil || previousChunks == nil {+ return nil+ }++ // Get trigger differences by comparing schema metadata+ currentMetadata := currentSchema.GetMetadata()+ previousMetadata := previousSchema.GetMetadata()+ if currentMetadata == nil || previousMetadata == nil {+ return nil+ }++ // Build trigger maps for current and previous schemas+ // Key format: schema.table.trigger_name (table-scoped)+ currentTriggers := make(map[string]*triggerWithContext)+ previousTriggers := make(map[string]*triggerWithContext)++ // Collect all triggers from current schema+ for _, schemaObj := range currentMetadata.Schemas {+ schemaName := schemaObj.Name+ if schemaName == "" {+ schemaName = "public"+ }+ for _, table := range schemaObj.Tables {+ for _, trigger := range table.Triggers {+ // Use table-scoped identifier: schema.table.trigger_name+ triggerKey := schemaName + "." + table.Name + "." + trigger.Name+ currentTriggers[triggerKey] = &triggerWithContext{+ trigger: trigger,+ schemaName: schemaName,+ tableName: table.Name,+ }+ }+ }+ }++ // Collect all triggers from previous schema+ for _, schemaObj := range previousMetadata.Schemas {+ schemaName := schemaObj.Name+ if schemaName == "" {+ schemaName = "public"+ }+ for _, table := range schemaObj.Tables {+ for _, trigger := range table.Triggers {+ // Use table-scoped identifier: schema.table.trigger_name+ triggerKey := schemaName + "." + table.Name + "." + trigger.Name+ previousTriggers[triggerKey] = &triggerWithContext{+ trigger: trigger,+ schemaName: schemaName,+ tableName: table.Name,+ }+ }+ }+ }++ // Process trigger additions: create new trigger chunks+ for triggerKey, currentTrigger := range currentTriggers {+ if _, exists := previousTriggers[triggerKey]; !exists {+ // New trigger - create a chunk for it+ err := createTriggerChunk(previousChunks, currentTrigger, triggerKey)+ if err != nil {+ return errors.Wrapf(err, "failed to create trigger chunk for %s", triggerKey)+ }+ }+ }++ // Process trigger modifications: update existing chunks+ for triggerKey, currentTrigger := range currentTriggers {+ if previousTrigger, exists := previousTriggers[triggerKey]; exists {+ // Trigger exists in both metadata+ // Only update if chunk exists in SDL (user explicitly defined it)+ // If chunk doesn't exist, skip - we don't force-add database objects that user didn't define+ if _, chunkExists := previousChunks.Triggers[triggerKey]; chunkExists {+ // Chunk exists - update if needed+ err := updateTriggerChunkIfNeeded(previousChunks, currentTrigger, previousTrigger, triggerKey)+ if err != nil {+ return errors.Wrapf(err, "failed to update trigger chunk for %s", triggerKey)+ }+ }+ // If chunk doesn't exist, skip - user didn't define this trigger in SDL+ }+ }++ // Process trigger deletions: remove dropped trigger chunks+ for triggerKey := range previousTriggers {+ if _, exists := currentTriggers[triggerKey]; !exists {+ // Trigger was dropped - remove it from chunks+ deleteTriggerChunk(previousChunks, triggerKey)+ }+ }++ return nil+}++// triggerWithContext holds trigger metadata with its schema and table context+type triggerWithContext struct {+ trigger *storepb.TriggerMetadata+ schemaName string+ tableName string+}++// createTriggerChunk creates a new CREATE TRIGGER chunk and adds it to the chunks+func createTriggerChunk(chunks *schema.SDLChunks, triggerCtx *triggerWithContext, triggerKey string) error {+ if triggerCtx == nil || triggerCtx.trigger == nil || chunks == nil {+ return nil+ }++ trigger := triggerCtx.trigger+ schemaName := triggerCtx.schemaName+ tableName := triggerCtx.tableName++ // Generate SDL text for the trigger+ triggerSDL := generateCreateTriggerSDL(schemaName, tableName, trigger)+ if triggerSDL == "" {+ return errors.New("failed to generate SDL for trigger")+ }++ // Parse the SDL to get AST node+ parseResult, err := pgparser.ParsePostgreSQL(triggerSDL)+ if err != nil {+ return errors.Wrapf(err, "failed to parse generated trigger SDL: %s", triggerSDL)+ }++ // Extract the CREATE TRIGGER AST node+ var triggerASTNode *parser.CreatetrigstmtContext+ antlr.ParseTreeWalkerDefault.Walk(&triggerExtractor{+ result: &triggerASTNode,+ }, parseResult.Tree)++ if triggerASTNode == nil {+ return errors.New("failed to extract CREATE TRIGGER AST node")+ }++ // Create and add the chunk+ chunk := &schema.SDLChunk{+ Identifier: triggerKey,+ ASTNode: triggerASTNode,+ }++ // Add comment if the trigger has one+ if trigger.Comment != "" {+ commentSQL := generateCommentOnTriggerSQL(schemaName, tableName, trigger.Name, trigger.Comment)+ commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)+ if err == nil && commentParseResult.Tree != nil {+ // Extract COMMENT ON TRIGGER AST node+ var commentASTNode *parser.CommentstmtContext+ antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{+ result: &commentASTNode,+ }, commentParseResult.Tree)++ if commentASTNode != nil {+ chunk.CommentStatements = []antlr.ParserRuleContext{commentASTNode}+ }+ }+ }++ if chunks.Triggers == nil {+ chunks.Triggers = make(map[string]*schema.SDLChunk)+ }+ chunks.Triggers[triggerKey] = chunk++ return nil+}++// updateTriggerChunkIfNeeded updates an existing trigger chunk if the definition has changed+func updateTriggerChunkIfNeeded(chunks *schema.SDLChunks, currentTriggerCtx, previousTriggerCtx *triggerWithContext, triggerKey string) error {+ if currentTriggerCtx == nil || previousTriggerCtx == nil || chunks == nil {+ return nil+ }++ currentTrigger := currentTriggerCtx.trigger+ previousTrigger := previousTriggerCtx.trigger+ schemaName := currentTriggerCtx.schemaName+ tableName := currentTriggerCtx.tableName++ // Get the existing chunk+ chunk, exists := chunks.Triggers[triggerKey]+ if !exists {+ return errors.Errorf("trigger chunk not found for key %s", triggerKey)+ }++ // Check if the trigger definition has changed+ // Trigger.Body contains the complete CREATE TRIGGER statement+ if currentTrigger.Body != previousTrigger.Body {+ // Trigger definition changed - regenerate the chunk+ triggerSDL := generateCreateTriggerSDL(schemaName, tableName, currentTrigger)+ if triggerSDL == "" {+ return errors.New("failed to generate SDL for trigger")+ }++ // Parse the new SDL to get a fresh AST node+ parseResult, err := pgparser.ParsePostgreSQL(triggerSDL)+ if err != nil {+ return errors.Wrapf(err, "failed to parse generated trigger SDL: %s", triggerSDL)+ }++ // Extract the CREATE TRIGGER AST node+ var triggerASTNode *parser.CreatetrigstmtContext+ antlr.ParseTreeWalkerDefault.Walk(&triggerExtractor{+ result: &triggerASTNode,+ }, parseResult.Tree)++ if triggerASTNode == nil {+ return errors.New("failed to extract CREATE TRIGGER AST node")+ }++ // Update the chunk's AST node+ chunk.ASTNode = triggerASTNode+ }++ // Handle comment changes independently of definition changes+ if currentTrigger.Comment != previousTrigger.Comment {+ if currentTrigger.Comment != "" {+ // New or updated comment+ commentSQL := generateCommentOnTriggerSQL(schemaName, tableName, currentTrigger.Name, currentTrigger.Comment)+ commentParseResult, err := pgparser.ParsePostgreSQL(commentSQL)+ if err == nil && commentParseResult.Tree != nil {+ // Extract COMMENT ON TRIGGER AST node+ var commentASTNode *parser.CommentstmtContext+ antlr.ParseTreeWalkerDefault.Walk(&commentExtractor{+ result: &commentASTNode,+ }, commentParseResult.Tree)++ if commentASTNode != nil {+ chunk.CommentStatements = []antlr.ParserRuleContext{commentASTNode}+ }+ }+ } else {+ // Comment was removed+ chunk.CommentStatements = nil+ }+ }++ return nil+}++// deleteTriggerChunk removes a trigger chunk from the chunks+func deleteTriggerChunk(chunks *schema.SDLChunks, triggerKey string) {+ if chunks != nil && chunks.Triggers != nil {+ delete(chunks.Triggers, triggerKey)+ }+}++// generateCreateTriggerSDL generates the SDL text for a CREATE TRIGGER statement+func generateCreateTriggerSDL(schemaName, tableName string, trigger *storepb.TriggerMetadata) string {+ if trigger == nil {+ return ""+ }++ var buf strings.Builder+ if err := writeTriggerSDL(&buf, schemaName, tableName, trigger); err != nil {+ return ""+ }++ return buf.String()+}++// generateCommentOnTriggerSQL generates a COMMENT ON TRIGGER statement+func generateCommentOnTriggerSQL(schemaName, tableName, triggerName, comment string) string {+ if schemaName == "" {+ schemaName = "public"+ }+ // Escape single quotes in comment+ escapedComment := strings.ReplaceAll(comment, "'", "''")+ return fmt.Sprintf("COMMENT ON TRIGGER \"%s\" ON \"%s\".\"%s\" IS '%s';", triggerName, schemaName, tableName, escapedComment)+}++// triggerExtractor extracts CREATE TRIGGER AST nodes+type triggerExtractor struct {+ *parser.BasePostgreSQLParserListener+ result **parser.CreatetrigstmtContext+}++func (e *triggerExtractor) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {+ if e.result != nil && *e.result == nil {+ *e.result = ctx+ }+}diff --git a/backend/plugin/schema/pg/trigger_differ.go b/backend/plugin/schema/pg/trigger_differ.gonew file mode 100644index 0000000000..c85e3b4832--- /dev/null+++ b/backend/plugin/schema/pg/trigger_differ.go@@ -0,0 +1,252 @@+package pg++import (+ "strings"++ parser "github.com/bytebase/parser/postgresql"++ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++// processStandaloneTriggerChanges analyzes standalone CREATE TRIGGER statement changes+// and adds them to the appropriate table's TriggerChanges+func processStandaloneTriggerChanges(currentChunks, previousChunks *schema.SDLChunks, currentDBSDLChunks *currentDatabaseSDLChunks, diff *schema.MetadataDiff) {+ if currentChunks == nil || previousChunks == nil {+ return+ }++ // Build map of affected tables for efficient lookups+ affectedTables := make(map[string]*schema.TableDiff, len(diff.TableChanges))+ for _, tableDiff := range diff.TableChanges {+ qualifiedTableName := tableDiff.SchemaName + "." + tableDiff.TableName+ affectedTables[qualifiedTableName] = tableDiff+ }++ // Step 1: Process current triggers (CREATE and MODIFY)+ for _, currentChunk := range currentChunks.Triggers {+ targetTableName := extractTableNameFromTriggerChunk(currentChunk.ASTNode)+ if targetTableName == "" {+ // No CREATE TRIGGER statement, might be comment-only chunk+ // Handle comment-only chunks separately+ if len(currentChunk.CommentStatements) > 0 {+ // Extract info from chunk identifier: schema.table.trigger_name+ parts := strings.Split(currentChunk.Identifier, ".")+ if len(parts) == 3 {+ schemaName := parts[0]+ tableName := parts[1]+ triggerName := parts[2]+ targetTableName = schemaName + "." + tableName++ // Add COMMENT changes+ for _, commentNode := range currentChunk.CommentStatements {+ commentText := extractCommentTextFromNode(commentNode)+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionCreate,+ ObjectType: schema.CommentObjectTypeTrigger,+ SchemaName: schemaName,+ TableName: targetTableName,+ ObjectName: triggerName,+ OldComment: "",+ NewComment: commentText,+ OldASTNode: nil,+ NewASTNode: commentNode,+ })+ }+ }+ }+ continue+ }++ if previousChunk, exists := previousChunks.Triggers[currentChunk.Identifier]; exists {+ // Trigger exists in both - check if modified+ currentText := getStandaloneTriggerText(currentChunk.ASTNode)+ previousText := getStandaloneTriggerText(previousChunk.ASTNode)++ // Extract trigger info once for both trigger and comment changes+ schemaName, tableName := parseSchemaAndTableFromQualifiedName(targetTableName)+ triggerName := extractTriggerNameFromAST(currentChunk.ASTNode)++ if currentText != previousText {+ // Usability check+ if currentDBSDLChunks.shouldSkipChunkDiffForUsability(currentText, currentChunk.Identifier) {+ continue+ }++ // Trigger was modified - use ALTER action (will be converted to CREATE OR REPLACE)+ tableDiff := getOrCreateTableDiff(diff, targetTableName, affectedTables)++ tableDiff.TriggerChanges = append(tableDiff.TriggerChanges, &schema.TriggerDiff{+ Action: schema.MetadataDiffActionAlter,+ SchemaName: schemaName,+ TableName: tableName,+ TriggerName: triggerName,+ OldASTNode: previousChunk.ASTNode,+ NewASTNode: currentChunk.ASTNode,+ })+ }++ // Check for comment changes independently of trigger definition changes+ currentCommentText := ""+ if len(currentChunk.CommentStatements) > 0 {+ currentCommentText = extractCommentTextFromNode(currentChunk.CommentStatements[0])+ }+ previousCommentText := ""+ if len(previousChunk.CommentStatements) > 0 {+ previousCommentText = extractCommentTextFromNode(previousChunk.CommentStatements[0])+ }++ if currentCommentText != previousCommentText {+ if currentCommentText != "" && previousCommentText == "" {+ // Comment added+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionCreate,+ ObjectType: schema.CommentObjectTypeTrigger,+ SchemaName: schemaName,+ TableName: targetTableName,+ ObjectName: triggerName,+ OldComment: "",+ NewComment: currentCommentText,+ OldASTNode: nil,+ NewASTNode: currentChunk.CommentStatements[0],+ })+ } else if currentCommentText == "" && previousCommentText != "" {+ // Comment removed+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionDrop,+ ObjectType: schema.CommentObjectTypeTrigger,+ SchemaName: schemaName,+ TableName: targetTableName,+ ObjectName: triggerName,+ OldComment: previousCommentText,+ NewComment: "",+ OldASTNode: previousChunk.CommentStatements[0],+ NewASTNode: nil,+ })+ } else if currentCommentText != "" && previousCommentText != "" {+ // Comment modified+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionAlter,+ ObjectType: schema.CommentObjectTypeTrigger,+ SchemaName: schemaName,+ TableName: targetTableName,+ ObjectName: triggerName,+ OldComment: previousCommentText,+ NewComment: currentCommentText,+ OldASTNode: previousChunk.CommentStatements[0],+ NewASTNode: currentChunk.CommentStatements[0],+ })+ }+ }+ } else {+ // New trigger+ tableDiff := getOrCreateTableDiff(diff, targetTableName, affectedTables)++ schemaName, tableName := parseSchemaAndTableFromQualifiedName(targetTableName)+ triggerName := extractTriggerNameFromAST(currentChunk.ASTNode)++ tableDiff.TriggerChanges = append(tableDiff.TriggerChanges, &schema.TriggerDiff{+ Action: schema.MetadataDiffActionCreate,+ SchemaName: schemaName,+ TableName: tableName,+ TriggerName: triggerName,+ NewASTNode: currentChunk.ASTNode,+ })++ // Add comments+ if len(currentChunk.CommentStatements) > 0 {+ for _, commentNode := range currentChunk.CommentStatements {+ commentText := extractCommentTextFromNode(commentNode)+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionCreate,+ ObjectType: schema.CommentObjectTypeTrigger,+ SchemaName: schemaName,+ TableName: targetTableName,+ ObjectName: triggerName,+ OldComment: "",+ NewComment: commentText,+ OldASTNode: nil,+ NewASTNode: commentNode,+ })+ }+ }+ }+ }++ // Step 2: Process previous triggers (DROP)+ for triggerName, previousChunk := range previousChunks.Triggers {+ if _, exists := currentChunks.Triggers[triggerName]; !exists {+ // Trigger was dropped+ targetTableName := extractTableNameFromTriggerChunk(previousChunk.ASTNode)+ if targetTableName == "" {+ // No CREATE TRIGGER statement, skip (comment-only chunks don't need DROP)+ continue+ }++ tableDiff := getOrCreateTableDiff(diff, targetTableName, affectedTables)++ schemaName, tableName := parseSchemaAndTableFromQualifiedName(targetTableName)+ triggerNameStr := extractTriggerNameFromAST(previousChunk.ASTNode)++ tableDiff.TriggerChanges = append(tableDiff.TriggerChanges, &schema.TriggerDiff{+ Action: schema.MetadataDiffActionDrop,+ SchemaName: schemaName,+ TableName: tableName,+ TriggerName: triggerNameStr,+ OldASTNode: previousChunk.ASTNode,+ })+ }+ }+}++// extractTableNameFromTriggerChunk extracts the table name from a trigger chunk's AST node+// Returns empty string if the AST node is not a CREATE TRIGGER statement or if extraction fails+func extractTableNameFromTriggerChunk(astNode any) string {+ if astNode == nil {+ return ""+ }+ triggerCtx, ok := astNode.(*parser.CreatetrigstmtContext)+ if !ok {+ return ""+ }+ return extractTableNameFromTrigger(triggerCtx)+}++// getStandaloneTriggerText returns the text representation of a CREATE TRIGGER statement+func getStandaloneTriggerText(astNode any) string {+ triggerStmt, ok := astNode.(*parser.CreatetrigstmtContext)+ if !ok || triggerStmt == nil {+ return ""+ }++ // Get text from token stream+ if parser := triggerStmt.GetParser(); parser != nil {+ if tokenStream := parser.GetTokenStream(); tokenStream != nil {+ start := triggerStmt.GetStart()+ stop := triggerStmt.GetStop()+ if start != nil && stop != nil {+ return tokenStream.GetTextFromTokens(start, stop)+ }+ }+ }++ return triggerStmt.GetText()+}++// extractTriggerNameFromAST extracts trigger name from CREATE TRIGGER AST+func extractTriggerNameFromAST(astNode any) string {+ triggerStmt, ok := astNode.(*parser.CreatetrigstmtContext)+ if !ok || triggerStmt == nil || triggerStmt.Name() == nil {+ return ""+ }+ return pgparser.NormalizePostgreSQLName(triggerStmt.Name())+}++// parseSchemaAndTableFromQualifiedName parses "schema.table" into separate parts+func parseSchemaAndTableFromQualifiedName(qualifiedName string) (schemaName, tableName string) {+ parts := strings.Split(qualifiedName, ".")+ if len(parts) == 2 {+ return parts[0], parts[1]+ }+ return "public", qualifiedName+}diff --git a/backend/plugin/schema/pg/trigger_drift_test.go b/backend/plugin/schema/pg/trigger_drift_test.gonew file mode 100644index 0000000000..1779e1c68e--- /dev/null+++ b/backend/plugin/schema/pg/trigger_drift_test.go@@ -0,0 +1,157 @@+package pg++import (+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+ "github.com/bytebase/bytebase/backend/store/model"+)++// TestTriggerDriftHandling tests the apply minimal changes (drift handling) for triggers+func TestTriggerDriftHandling(t *testing.T) {+ t.Run("New trigger added to database", func(t *testing.T) {+ // User SDL (no trigger)+ userSDL := `+ CREATE TABLE users (+ id SERIAL PRIMARY KEY,+ name VARCHAR(100)+ );++ CREATE FUNCTION audit_log() RETURNS TRIGGER AS $$+ BEGIN+ RAISE NOTICE 'Audit';+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;+ `++ // Database has a new trigger that wasn't in SDL+ currentDBMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ {Name: "name", Type: "varchar(100)"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "audit_trigger",+ Body: "CREATE TRIGGER audit_trigger AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ },+ },+ },+ },+ Functions: []*storepb.FunctionMetadata{+ {+ Name: "audit_log",+ Definition: "CREATE FUNCTION audit_log() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Audit'; RETURN NEW; END; $$ LANGUAGE plpgsql;",+ },+ },+ },+ },+ }++ previousDBMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ {Name: "name", Type: "varchar(100)"},+ },+ },+ },+ Functions: []*storepb.FunctionMetadata{+ {+ Name: "audit_log",+ Definition: "CREATE FUNCTION audit_log() RETURNS TRIGGER AS $$ BEGIN RAISE NOTICE 'Audit'; RETURN NEW; END; $$ LANGUAGE plpgsql;",+ },+ },+ },+ },+ }++ currentSchema := model.NewDatabaseSchema(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)+ previousSchema := model.NewDatabaseSchema(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)++ diff, err := GetSDLDiff(userSDL, userSDL, currentSchema, previousSchema)+ require.NoError(t, err)++ // Should detect the new trigger+ require.NotNil(t, diff, "Diff should not be nil")++ // Drift handling should have added the trigger to the diff+ // The exact behavior depends on implementation details+ t.Logf("TableChanges count: %d", len(diff.TableChanges))+ for _, tc := range diff.TableChanges {+ t.Logf("Table: %s.%s, TriggerChanges: %d", tc.SchemaName, tc.TableName, len(tc.TriggerChanges))+ }+ })++ t.Run("Apply trigger changes to chunks", func(t *testing.T) {+ // Create test SDL chunks+ chunks := &schema.SDLChunks{+ Triggers: make(map[string]*schema.SDLChunk),+ }++ currentDBMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "new_trigger",+ Body: "CREATE TRIGGER new_trigger AFTER UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f()",+ },+ },+ },+ },+ },+ },+ }++ previousDBMetadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ },+ },+ },+ },+ }++ currentSchema := model.NewDatabaseSchema(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)+ previousSchema := model.NewDatabaseSchema(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)++ // Apply changes+ err := applyTriggerChangesToChunks(chunks, currentSchema, previousSchema)+ require.NoError(t, err)++ // Should have created a new chunk+ triggerKey := "public.users.new_trigger"+ chunk, exists := chunks.Triggers[triggerKey]+ require.True(t, exists, "Should have trigger chunk with key %s", triggerKey)+ require.NotNil(t, chunk, "Chunk should not be nil")+ require.NotNil(t, chunk.ASTNode, "Chunk should have ASTNode")+ })+}diff --git a/backend/plugin/schema/pg/trigger_drop_dependency_test.go b/backend/plugin/schema/pg/trigger_drop_dependency_test.gonew file mode 100644index 0000000000..f37af35ae1--- /dev/null+++ b/backend/plugin/schema/pg/trigger_drop_dependency_test.go@@ -0,0 +1,326 @@+package pg++import (+ "strings"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestDropTriggerDependencyOrder(t *testing.T) {+ // Previous SDL with tables, functions, and triggers+ previousSDL := `+ CREATE TABLE test_products (+ id SERIAL PRIMARY KEY,+ name VARCHAR(100),+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE TABLE test_orders (+ id SERIAL PRIMARY KEY,+ product_id INTEGER,+ quantity INTEGER,+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE TABLE audit_log (+ id SERIAL PRIMARY KEY,+ table_name VARCHAR(50),+ operation VARCHAR(10),+ changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE FUNCTION update_timestamp_trigger_func()+ RETURNS TRIGGER AS $$+ BEGIN+ NEW.updated_at = CURRENT_TIMESTAMP;+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE FUNCTION audit_trigger_func()+ RETURNS TRIGGER AS $$+ BEGIN+ INSERT INTO audit_log (table_name, operation)+ VALUES (TG_TABLE_NAME, TG_OP);+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON test_products+ FOR EACH ROW EXECUTE FUNCTION update_timestamp_trigger_func();++ CREATE TRIGGER audit_insert_trigger+ AFTER INSERT ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_update_trigger+ AFTER UPDATE ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_delete_trigger+ AFTER DELETE ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON test_orders+ FOR EACH ROW EXECUTE FUNCTION update_timestamp_trigger_func();++ CREATE TRIGGER audit_insert_trigger+ AFTER INSERT ON test_orders+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_delete_trigger+ AFTER DELETE ON test_orders+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();+ `++ // Current SDL is empty - drop everything+ currentSDL := ``++ // Generate diff and migration (AST-only mode)+ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Debug: print diff information+ t.Logf("Number of table changes: %d", len(diff.TableChanges))+ for i, tableDiff := range diff.TableChanges {+ t.Logf("Table %d: %s.%s, Action=%s, TriggerChanges=%d",+ i, tableDiff.SchemaName, tableDiff.TableName, tableDiff.Action, len(tableDiff.TriggerChanges))+ for j, triggerDiff := range tableDiff.TriggerChanges {+ t.Logf(" Trigger %d: %s, Action=%s", j, triggerDiff.TriggerName, triggerDiff.Action)+ }+ }++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ t.Logf("Migration:\n%s", migration)++ // Find positions of DROP statements+ dropTriggerIdx := strings.Index(migration, "DROP TRIGGER")+ dropFunctionIdx := strings.Index(migration, "DROP FUNCTION")+ dropTableIdx := strings.Index(migration, "DROP TABLE")++ t.Logf("Indices: dropTrigger=%d, dropFunction=%d, dropTable=%d", dropTriggerIdx, dropFunctionIdx, dropTableIdx)++ // Verify DROP order: triggers must be dropped before functions+ // Functions must be dropped before tables (or at least before tables that don't depend on them)+ assert.NotEqual(t, -1, dropTriggerIdx, "Should have DROP TRIGGER statements")+ assert.NotEqual(t, -1, dropFunctionIdx, "Should have DROP FUNCTION statements")+ assert.NotEqual(t, -1, dropTableIdx, "Should have DROP TABLE statements")++ // Critical: triggers must be dropped before functions they depend on+ assert.Less(t, dropTriggerIdx, dropFunctionIdx, "DROP TRIGGER must come before DROP FUNCTION to avoid dependency errors")++ // Functions should be dropped before or after tables (depends on implementation)+ // But triggers MUST be before functions+}++func TestCreateTriggerDependencyOrder(t *testing.T) {+ // Previous SDL is empty+ previousSDL := ``++ // Current SDL with tables, functions, and triggers+ currentSDL := `+ CREATE TABLE test_products (+ id SERIAL PRIMARY KEY,+ name VARCHAR(100),+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE TABLE test_orders (+ id SERIAL PRIMARY KEY,+ product_id INTEGER,+ quantity INTEGER,+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE TABLE audit_log (+ id SERIAL PRIMARY KEY,+ table_name VARCHAR(50),+ operation VARCHAR(10),+ changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE FUNCTION update_timestamp_trigger_func()+ RETURNS TRIGGER AS $$+ BEGIN+ NEW.updated_at = CURRENT_TIMESTAMP;+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE FUNCTION audit_trigger_func()+ RETURNS TRIGGER AS $$+ BEGIN+ INSERT INTO audit_log (table_name, operation)+ VALUES (TG_TABLE_NAME, TG_OP);+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON test_products+ FOR EACH ROW EXECUTE FUNCTION update_timestamp_trigger_func();++ CREATE TRIGGER audit_insert_trigger+ AFTER INSERT ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_update_trigger+ AFTER UPDATE ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_delete_trigger+ AFTER DELETE ON test_products+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON test_orders+ FOR EACH ROW EXECUTE FUNCTION update_timestamp_trigger_func();++ CREATE TRIGGER audit_insert_trigger+ AFTER INSERT ON test_orders+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();++ CREATE TRIGGER audit_delete_trigger+ AFTER DELETE ON test_orders+ FOR EACH ROW EXECUTE FUNCTION audit_trigger_func();+ `++ // Generate diff and migration (AST-only mode)+ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Debug: print diff information+ t.Logf("Number of table changes: %d", len(diff.TableChanges))+ for i, tableDiff := range diff.TableChanges {+ t.Logf("Table %d: %s.%s, Action=%s, TriggerChanges=%d",+ i, tableDiff.SchemaName, tableDiff.TableName, tableDiff.Action, len(tableDiff.TriggerChanges))+ for j, triggerDiff := range tableDiff.TriggerChanges {+ t.Logf(" Trigger %d: %s, Action=%s", j, triggerDiff.TriggerName, triggerDiff.Action)+ }+ }++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ t.Logf("Migration:\n%s", migration)++ // Find positions of CREATE statements+ createTableIdx := strings.Index(migration, "CREATE TABLE")+ createFunctionIdx := strings.Index(migration, "CREATE FUNCTION") // Note: Not "CREATE OR REPLACE" for new functions+ createTriggerIdx := strings.Index(migration, "CREATE OR REPLACE TRIGGER")++ t.Logf("Indices: createTable=%d, createFunction=%d, createTrigger=%d",+ createTableIdx, createFunctionIdx, createTriggerIdx)++ // Verify CREATE order: tables must be created before functions and triggers+ assert.NotEqual(t, -1, createTableIdx, "Should have CREATE TABLE statements")+ assert.NotEqual(t, -1, createFunctionIdx, "Should have CREATE FUNCTION statements")+ assert.NotEqual(t, -1, createTriggerIdx, "Should have CREATE TRIGGER statements")++ // Critical: tables must be created before triggers (triggers reference tables)+ assert.Less(t, createTableIdx, createTriggerIdx, "CREATE TABLE must come before CREATE TRIGGER")++ // Functions must be created before triggers (triggers call functions)+ assert.Less(t, createFunctionIdx, createTriggerIdx, "CREATE FUNCTION must come before CREATE TRIGGER to avoid dependency errors")++ // Verify no duplicate triggers+ firstTrigger := strings.Index(migration, "CREATE OR REPLACE TRIGGER")+ assert.NotEqual(t, -1, firstTrigger, "Should have at least one CREATE TRIGGER")++ // Count total triggers (should match the number we expect)+ triggerCount := strings.Count(migration, "CREATE OR REPLACE TRIGGER")+ t.Logf("Total triggers in migration: %d", triggerCount)+ assert.Equal(t, 7, triggerCount, "Should have exactly 7 triggers (4 from test_products, 3 from test_orders)")+}++func TestSameTriggerNameOnDifferentTables(t *testing.T) {+ // Test that triggers with the same name on different tables are handled correctly+ // In PostgreSQL, trigger names are table-scoped, not schema-scoped+ // So "public.table1.trigger_name" and "public.table2.trigger_name" should be different++ currentSDL := `+ CREATE TABLE users (+ id SERIAL PRIMARY KEY,+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE TABLE orders (+ id SERIAL PRIMARY KEY,+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP+ );++ CREATE FUNCTION update_timestamp()+ RETURNS TRIGGER AS $$+ BEGIN+ NEW.updated_at = CURRENT_TIMESTAMP;+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ -- Same trigger name on different tables+ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON users+ FOR EACH ROW EXECUTE FUNCTION update_timestamp();++ CREATE TRIGGER update_timestamp_trigger+ BEFORE UPDATE ON orders+ FOR EACH ROW EXECUTE FUNCTION update_timestamp();+ `++ previousSDL := ``++ // Generate diff and migration (AST-only mode)+ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Debug: print diff information+ t.Logf("Number of table changes: %d", len(diff.TableChanges))++ totalTriggers := 0+ for _, tableDiff := range diff.TableChanges {+ t.Logf("Table: %s.%s, Action=%s, TriggerChanges=%d",+ tableDiff.SchemaName, tableDiff.TableName, tableDiff.Action, len(tableDiff.TriggerChanges))+ for _, triggerDiff := range tableDiff.TriggerChanges {+ t.Logf(" Trigger: %s, Action=%s", triggerDiff.TriggerName, triggerDiff.Action)+ totalTriggers+++ }+ }++ // Should have 2 triggers (one for each table)+ assert.Equal(t, 2, totalTriggers, "Should have 2 triggers (one for each table)")++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ t.Logf("Migration:\n%s", migration)++ // Verify both triggers are in the migration+ assert.Contains(t, migration, "ON users", "Should have trigger on users table")+ assert.Contains(t, migration, "ON orders", "Should have trigger on orders table")++ // Count how many times the trigger is created+ // Should be 2 (once for users, once for orders)+ triggerCount := 0+ if assert.Contains(t, migration, "CREATE OR REPLACE TRIGGER update_timestamp_trigger") {+ // Count occurrences manually by checking both table references+ hasUsersTrigger := assert.Contains(t, migration, "update_timestamp_trigger") &&+ assert.Contains(t, migration, "ON users")+ hasOrdersTrigger := assert.Contains(t, migration, "update_timestamp_trigger") &&+ assert.Contains(t, migration, "ON orders")++ if hasUsersTrigger {+ triggerCount+++ }+ if hasOrdersTrigger {+ triggerCount+++ }+ }++ assert.Equal(t, 2, triggerCount, "Should have 2 CREATE TRIGGER statements (one for each table)")+}diff --git a/backend/plugin/schema/pg/trigger_sdl_diff_test.go b/backend/plugin/schema/pg/trigger_sdl_diff_test.gonew file mode 100644index 0000000000..adb883ffdc--- /dev/null+++ b/backend/plugin/schema/pg/trigger_sdl_diff_test.go@@ -0,0 +1,739 @@+package pg++import (+ "strings"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/schema"+)++func TestTriggerDiffStructure(t *testing.T) {+ // Test that TriggerDiff has all required fields for SDL processing+ currentSDL := `+ CREATE TABLE users (+ id SERIAL PRIMARY KEY,+ name VARCHAR(100)+ );++ CREATE FUNCTION audit_log() RETURNS TRIGGER AS $$+ BEGIN+ RAISE NOTICE 'Audit';+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit_log();+ `++ previousSDL := ""++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)+ require.Len(t, diff.TableChanges, 1, "Should have one table change")++ tableDiff := diff.TableChanges[0]+ require.Len(t, tableDiff.TriggerChanges, 1, "Should have one trigger change")++ triggerDiff := tableDiff.TriggerChanges[0]+ assert.Equal(t, schema.MetadataDiffActionCreate, triggerDiff.Action)+ assert.NotNil(t, triggerDiff.NewASTNode, "Should have AST node")+ // These fields should exist after we update the structure+ // assert.Equal(t, "public", triggerDiff.SchemaName)+ // assert.Equal(t, "users", triggerDiff.TableName)+ // assert.Equal(t, "audit_trigger", triggerDiff.TriggerName)+}++func TestCreateTriggerExtraction(t *testing.T) {+ tests := []struct {+ name string+ sql string+ expectedTriggers int+ }{+ {+ name: "Simple trigger",+ sql: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ expectedTriggers: 1,+ },+ {+ name: "Multiple triggers on same table",+ sql: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ CREATE TRIGGER t2 BEFORE UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ expectedTriggers: 2,+ },+ {+ name: "Trigger with schema-qualified table",+ sql: `+ CREATE SCHEMA app;+ CREATE TABLE app.users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION app.f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON app.users FOR EACH ROW EXECUTE FUNCTION app.f();+ `,+ expectedTriggers: 1,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ diff, err := GetSDLDiff(tt.sql, "", nil, nil)+ require.NoError(t, err)++ totalTriggers := 0+ for _, tableDiff := range diff.TableChanges {+ totalTriggers += len(tableDiff.TriggerChanges)+ }++ assert.Equal(t, tt.expectedTriggers, totalTriggers)+ })+ }+}++func TestTriggerCommentExtraction(t *testing.T) {+ sql := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ COMMENT ON TRIGGER audit_trigger ON users IS 'Audit log trigger';+ `++ diff, err := GetSDLDiff(sql, "", nil, nil)+ require.NoError(t, err)++ // Check that comment change exists+ found := false+ for _, commentDiff := range diff.CommentChanges {+ if commentDiff.ObjectType == schema.CommentObjectTypeTrigger &&+ commentDiff.ObjectName == "audit_trigger" &&+ commentDiff.NewComment == "Audit log trigger" {+ found = true+ break+ }+ }+ assert.True(t, found, "Should have trigger comment")+}++func TestDropTriggerMigration(t *testing.T) {+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `+ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ assert.Contains(t, migration, "DROP TRIGGER")+ assert.Contains(t, migration, "audit_trigger")+ assert.Contains(t, migration, "ON")+ assert.Contains(t, migration, "users")+}++func TestCreateTriggerMigrationWithDependencyOrder(t *testing.T) {+ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit_log() RETURNS TRIGGER AS $$+ BEGIN+ RAISE NOTICE 'Audit';+ RETURN NEW;+ END;+ $$ LANGUAGE plpgsql;++ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit_log();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ // Print migration for debugging+ t.Logf("Migration:\n%s", migration)++ // Verify CREATE OR REPLACE TRIGGER is in migration+ assert.Contains(t, migration, "CREATE OR REPLACE TRIGGER")+ assert.Contains(t, migration, "audit_trigger")++ // Verify dependency order: Both TABLE and FUNCTION must be created before TRIGGER+ // The order between TABLE and FUNCTION doesn't matter - either is valid in PostgreSQL+ // since trigger functions don't reference the table until the trigger is created+ tableIdx := strings.Index(migration, "CREATE TABLE")+ functionIdx := strings.Index(migration, "CREATE FUNCTION audit_log")+ triggerIdx := strings.Index(migration, "CREATE OR REPLACE TRIGGER audit_trigger")++ t.Logf("Indices: table=%d, function=%d, trigger=%d", tableIdx, functionIdx, triggerIdx)++ // Both table and function must exist before trigger+ assert.Less(t, tableIdx, triggerIdx, "Table must be created before trigger")+ assert.Less(t, functionIdx, triggerIdx, "Function must be created before trigger")+}++func TestTriggerCommentMigration(t *testing.T) {+ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ COMMENT ON TRIGGER audit_trigger ON users IS 'Audit log trigger';+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ assert.Contains(t, migration, "COMMENT ON TRIGGER")+ assert.Contains(t, migration, "audit_trigger")+ assert.Contains(t, migration, "Audit log trigger")+}++func TestStandaloneTriggerDiff(t *testing.T) {+ tests := []struct {+ name string+ previousUserSDL string+ currentSDL string+ expectedTriggerDiff int+ expectedActions []schema.MetadataDiffAction+ }{+ {+ name: "Create new trigger",+ previousUserSDL: "",+ currentSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ expectedTriggerDiff: 1,+ expectedActions: []schema.MetadataDiffAction{schema.MetadataDiffActionCreate},+ },+ {+ name: "Drop trigger",+ previousUserSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ currentSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ `,+ expectedTriggerDiff: 1,+ expectedActions: []schema.MetadataDiffAction{schema.MetadataDiffActionDrop},+ },+ {+ name: "Modify trigger (CREATE OR REPLACE)",+ previousUserSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ currentSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT OR UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ expectedTriggerDiff: 1, // ALTER (CREATE OR REPLACE)+ expectedActions: []schema.MetadataDiffAction{schema.MetadataDiffActionAlter},+ },+ {+ name: "No changes to trigger",+ previousUserSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ currentSDL: `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ `,+ expectedTriggerDiff: 0,+ expectedActions: []schema.MetadataDiffAction{},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ diff, err := GetSDLDiff(tt.currentSDL, tt.previousUserSDL, nil, nil)+ require.NoError(t, err)++ totalTriggers := 0+ var actions []schema.MetadataDiffAction+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ totalTriggers+++ actions = append(actions, triggerDiff.Action)+ }+ }++ assert.Equal(t, tt.expectedTriggerDiff, totalTriggers)+ if len(tt.expectedActions) == 0 {+ assert.Empty(t, actions)+ } else {+ assert.Equal(t, tt.expectedActions, actions)+ }+ })+ }+}++func TestTriggerSDLIntegration(t *testing.T) {+ t.Run("Multiple triggers on same table", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE orders (id SERIAL PRIMARY KEY, status VARCHAR(20));+ CREATE FUNCTION log_insert() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE FUNCTION log_update() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;++ CREATE TRIGGER insert_trigger AFTER INSERT ON orders FOR EACH ROW EXECUTE FUNCTION log_insert();+ CREATE TRIGGER update_trigger BEFORE UPDATE ON orders FOR EACH ROW EXECUTE FUNCTION log_update();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ totalTriggers := 0+ for _, tableDiff := range diff.TableChanges {+ totalTriggers += len(tableDiff.TriggerChanges)+ }+ assert.Equal(t, 2, totalTriggers, "Should have 2 triggers")++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "insert_trigger")+ assert.Contains(t, migration, "update_trigger")+ })++ t.Run("Trigger with schema-qualified table", func(t *testing.T) {+ currentSDL := `+ CREATE SCHEMA app;+ CREATE TABLE app.events (id SERIAL PRIMARY KEY);+ CREATE FUNCTION app.notify() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER event_trigger AFTER INSERT ON app.events FOR EACH ROW EXECUTE FUNCTION app.notify();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ found := false+ for _, tableDiff := range diff.TableChanges {+ if tableDiff.SchemaName == "app" && tableDiff.TableName == "events" {+ assert.Len(t, tableDiff.TriggerChanges, 1)+ found = true+ }+ }+ assert.True(t, found, "Should find trigger on app.events")+ })++ t.Run("Trigger with WHEN condition", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE products (id SERIAL PRIMARY KEY, price NUMERIC);+ CREATE FUNCTION check_price() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER price_check+ BEFORE UPDATE ON products+ FOR EACH ROW+ WHEN (NEW.price > 1000)+ EXECUTE FUNCTION check_price();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "WHEN")+ assert.Contains(t, migration, "NEW.price > 1000")+ })++ t.Run("Trigger modification preserves other triggers", func(t *testing.T) {+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ CREATE TRIGGER t2 AFTER UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f();+ `+ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT OR UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f();+ CREATE TRIGGER t2 AFTER UPDATE ON users FOR EACH ROW EXECUTE FUNCTION f();+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Should have 1 change for t1 (ALTER using CREATE OR REPLACE), none for t2+ totalChanges := 0+ alterChanges := 0+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ totalChanges+++ if triggerDiff.Action == schema.MetadataDiffActionAlter {+ alterChanges+++ }+ }+ }+ assert.Equal(t, 1, totalChanges, "Should only modify t1 (ALTER)")+ assert.Equal(t, 1, alterChanges, "Should use ALTER action (CREATE OR REPLACE)")+ })++ t.Run("Trigger with multiple events", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE audit_log (id SERIAL PRIMARY KEY);+ CREATE FUNCTION log_changes() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER multi_event_trigger+ AFTER INSERT OR UPDATE OR DELETE ON audit_log+ FOR EACH ROW EXECUTE FUNCTION log_changes();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "CREATE OR REPLACE TRIGGER")+ assert.Contains(t, migration, "INSERT OR UPDATE OR DELETE")+ })++ t.Run("Trigger with FOR EACH STATEMENT", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE statements (id SERIAL PRIMARY KEY);+ CREATE FUNCTION stmt_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NULL; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER statement_level_trigger+ AFTER INSERT ON statements+ FOR EACH STATEMENT EXECUTE FUNCTION stmt_trigger();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "FOR EACH STATEMENT")+ })++ t.Run("Multiple comments on triggers", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE events (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON events FOR EACH ROW EXECUTE FUNCTION f();+ CREATE TRIGGER t2 AFTER UPDATE ON events FOR EACH ROW EXECUTE FUNCTION f();+ COMMENT ON TRIGGER t1 ON events IS 'Insert trigger';+ COMMENT ON TRIGGER t2 ON events IS 'Update trigger';+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ // Check both comments are extracted+ triggerCommentCount := 0+ for _, commentDiff := range diff.CommentChanges {+ if commentDiff.ObjectType == schema.CommentObjectTypeTrigger {+ triggerCommentCount+++ }+ }+ assert.Equal(t, 2, triggerCommentCount, "Should have 2 trigger comments")+ })++ t.Run("Drop trigger removes comment", func(t *testing.T) {+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER t1 AFTER INSERT ON users FOR EACH ROW EXECUTE FUNCTION f();+ COMMENT ON TRIGGER t1 ON users IS 'My trigger';+ `+ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION f() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Should have trigger drop+ found := false+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionDrop {+ found = true+ }+ }+ }+ assert.True(t, found, "Should have trigger drop action")+ })++ t.Run("Trigger referencing columns", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE inventory (id SERIAL PRIMARY KEY, stock INT);+ CREATE FUNCTION check_stock() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER stock_check+ BEFORE UPDATE OF stock ON inventory+ FOR EACH ROW EXECUTE FUNCTION check_stock();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "UPDATE OF stock")+ })++ t.Run("INSTEAD OF trigger on view", func(t *testing.T) {+ currentSDL := `+ CREATE TABLE base_table (id SERIAL PRIMARY KEY);+ CREATE VIEW my_view AS SELECT * FROM base_table;+ CREATE FUNCTION instead_trigger() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER view_trigger+ INSTEAD OF INSERT ON my_view+ FOR EACH ROW EXECUTE FUNCTION instead_trigger();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)+ assert.Contains(t, migration, "INSTEAD OF INSERT")+ })++ t.Run("CREATE OR REPLACE conversion test", func(t *testing.T) {+ // Test that CREATE TRIGGER is converted to CREATE OR REPLACE TRIGGER+ currentSDL := `+ CREATE TABLE test_table (id SERIAL PRIMARY KEY);+ CREATE FUNCTION test_func() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER test_trigger+ AFTER INSERT ON test_table+ FOR EACH ROW EXECUTE FUNCTION test_func();+ `++ diff, err := GetSDLDiff(currentSDL, "", nil, nil)+ require.NoError(t, err)++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ // Should contain CREATE OR REPLACE TRIGGER, not just CREATE TRIGGER+ assert.Contains(t, migration, "CREATE OR REPLACE TRIGGER")+ assert.NotContains(t, migration, "CREATE TRIGGER test_trigger\n")+ })++ t.Run("Trigger modification uses CREATE OR REPLACE", func(t *testing.T) {+ // Test that modifying a trigger uses CREATE OR REPLACE instead of DROP + CREATE+ previousSDL := `+ CREATE TABLE test_table (id SERIAL PRIMARY KEY);+ CREATE FUNCTION test_func() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER test_trigger+ AFTER INSERT ON test_table+ FOR EACH ROW EXECUTE FUNCTION test_func();+ `++ currentSDL := `+ CREATE TABLE test_table (id SERIAL PRIMARY KEY);+ CREATE FUNCTION test_func() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER test_trigger+ AFTER INSERT OR UPDATE ON test_table+ FOR EACH ROW EXECUTE FUNCTION test_func();+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Should have 1 ALTER action (not DROP + CREATE)+ var alterCount int+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionAlter {+ alterCount+++ }+ }+ }+ assert.Equal(t, 1, alterCount, "Should use ALTER action")++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ // Should use CREATE OR REPLACE+ assert.Contains(t, migration, "CREATE OR REPLACE TRIGGER")+ // Should NOT contain DROP TRIGGER+ assert.NotContains(t, migration, "DROP TRIGGER")+ })++ t.Run("Modify trigger comment only", func(t *testing.T) {+ // Test that modifying only the trigger comment doesn't trigger ALTER on the trigger itself+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ COMMENT ON TRIGGER audit_trigger ON users IS 'Original comment';+ `++ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ COMMENT ON TRIGGER audit_trigger ON users IS 'Updated comment';+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Trigger itself should NOT have ALTER action (definition unchanged)+ triggerAlterCount := 0+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionAlter {+ triggerAlterCount+++ }+ }+ }+ assert.Equal(t, 0, triggerAlterCount, "Trigger should not have ALTER action when only comment changes")++ // Should have comment change+ commentChanged := false+ for _, commentDiff := range diff.CommentChanges {+ if commentDiff.ObjectType == schema.CommentObjectTypeTrigger &&+ commentDiff.ObjectName == "audit_trigger" &&+ commentDiff.OldComment == "Original comment" &&+ commentDiff.NewComment == "Updated comment" {+ commentChanged = true+ }+ }+ assert.True(t, commentChanged, "Should have trigger comment change")++ // Migration should only contain COMMENT statement, not CREATE OR REPLACE TRIGGER+ migration, err := generateMigration(diff)+ require.NoError(t, err)++ assert.Contains(t, migration, "COMMENT ON TRIGGER", "Should have COMMENT ON TRIGGER")+ assert.Contains(t, migration, "Updated comment", "Should have new comment text")+ assert.NotContains(t, migration, "CREATE OR REPLACE TRIGGER", "Should NOT recreate trigger when only comment changes")+ })++ t.Run("Add comment to trigger without comment", func(t *testing.T) {+ // Test adding a comment to a trigger that previously had no comment+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ `++ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ COMMENT ON TRIGGER audit_trigger ON users IS 'New comment';+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Trigger should NOT have ALTER action+ triggerAlterCount := 0+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionAlter {+ triggerAlterCount+++ }+ }+ }+ assert.Equal(t, 0, triggerAlterCount, "Trigger should not have ALTER action when adding comment")++ // Should have comment addition+ commentAdded := false+ for _, commentDiff := range diff.CommentChanges {+ if commentDiff.ObjectType == schema.CommentObjectTypeTrigger &&+ commentDiff.ObjectName == "audit_trigger" &&+ commentDiff.Action == schema.MetadataDiffActionCreate &&+ commentDiff.NewComment == "New comment" {+ commentAdded = true+ }+ }+ assert.True(t, commentAdded, "Should have comment addition")++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ assert.Contains(t, migration, "COMMENT ON TRIGGER", "Should have COMMENT ON TRIGGER")+ assert.NotContains(t, migration, "CREATE OR REPLACE TRIGGER", "Should NOT recreate trigger")+ })++ t.Run("Remove trigger comment", func(t *testing.T) {+ // Test removing a comment from a trigger+ previousSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ COMMENT ON TRIGGER audit_trigger ON users IS 'Old comment';+ `++ currentSDL := `+ CREATE TABLE users (id SERIAL PRIMARY KEY);+ CREATE FUNCTION audit() RETURNS TRIGGER AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;+ CREATE TRIGGER audit_trigger+ AFTER INSERT ON users+ FOR EACH ROW EXECUTE FUNCTION audit();+ `++ diff, err := GetSDLDiff(currentSDL, previousSDL, nil, nil)+ require.NoError(t, err)++ // Trigger should NOT have ALTER action+ triggerAlterCount := 0+ for _, tableDiff := range diff.TableChanges {+ for _, triggerDiff := range tableDiff.TriggerChanges {+ if triggerDiff.Action == schema.MetadataDiffActionAlter {+ triggerAlterCount+++ }+ }+ }+ assert.Equal(t, 0, triggerAlterCount, "Trigger should not have ALTER action when removing comment")++ // Should have comment drop+ commentDropped := false+ for _, commentDiff := range diff.CommentChanges {+ if commentDiff.ObjectType == schema.CommentObjectTypeTrigger &&+ commentDiff.ObjectName == "audit_trigger" &&+ commentDiff.Action == schema.MetadataDiffActionDrop {+ commentDropped = true+ }+ }+ assert.True(t, commentDropped, "Should have comment drop action")++ migration, err := generateMigration(diff)+ require.NoError(t, err)++ assert.Contains(t, migration, "COMMENT ON TRIGGER", "Should have COMMENT ON TRIGGER")+ assert.Contains(t, migration, "NULL", "Should set comment to NULL")+ assert.NotContains(t, migration, "CREATE OR REPLACE TRIGGER", "Should NOT recreate trigger")+ })+}diff --git a/backend/plugin/schema/pg/trigger_sdl_output_test.go b/backend/plugin/schema/pg/trigger_sdl_output_test.gonew file mode 100644index 0000000000..23ed1506d4--- /dev/null+++ b/backend/plugin/schema/pg/trigger_sdl_output_test.go@@ -0,0 +1,215 @@+package pg++import (+ "strings"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/schema"+)++func TestTriggerSDLSingleFileOutput(t *testing.T) {+ metadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "audit_trigger",+ Body: "CREATE TRIGGER audit_trigger AFTER INSERT ON public.users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ },+ },+ },+ },+ },+ },+ }++ ctx := schema.GetDefinitionContext{+ SDLFormat: true,+ }++ result, err := GetDatabaseDefinition(ctx, metadata)+ require.NoError(t, err)++ assert.Contains(t, result, "CREATE TRIGGER audit_trigger")+ assert.Contains(t, result, "AFTER INSERT ON public.users")+ assert.Contains(t, result, "FOR EACH ROW EXECUTE FUNCTION audit_log()")+}++func TestTriggerSDLMultiFileOutput(t *testing.T) {+ metadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "audit_trigger",+ Body: "CREATE TRIGGER audit_trigger AFTER INSERT ON public.users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ },+ },+ },+ },+ },+ },+ }++ ctx := schema.GetDefinitionContext{+ SDLFormat: true,+ }++ result, err := GetMultiFileDatabaseDefinition(ctx, metadata)+ require.NoError(t, err)+ require.NotNil(t, result)++ // Find the users table file+ var usersFileContent string+ for _, file := range result.Files {+ if file.Name == "schemas/public/tables/users.sql" {+ usersFileContent = file.Content+ break+ }+ }++ require.NotEmpty(t, usersFileContent, "Should have users table file")+ assert.Contains(t, usersFileContent, "CREATE TRIGGER audit_trigger")+ assert.Contains(t, usersFileContent, "AFTER INSERT ON public.users")+}++func TestTriggerSDLWithCompleteDefinition(t *testing.T) {+ // Test that triggers with complete CREATE TRIGGER statements in Body are output correctly+ // This simulates triggers dumped from the database where Body contains the full statement+ metadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "ci_builds",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "ci_builds_loose_fk_trigger",+ Body: "CREATE TRIGGER ci_builds_loose_fk_trigger AFTER DELETE ON public.ci_builds REFERENCING OLD TABLE AS old_table FOR EACH STATEMENT EXECUTE FUNCTION public.loose_foreign_key_on_builds_projects()",+ },+ },+ },+ },+ },+ },+ }++ ctx := schema.GetDefinitionContext{+ SDLFormat: true,+ }++ result, err := GetDatabaseDefinition(ctx, metadata)+ require.NoError(t, err)++ // Should contain only one CREATE TRIGGER (not duplicated)+ createTriggerCount := strings.Count(result, "CREATE TRIGGER ci_builds_loose_fk_trigger")+ assert.Equal(t, 1, createTriggerCount, "CREATE TRIGGER should appear exactly once, not duplicated")++ // Should contain the complete trigger definition+ assert.Contains(t, result, "AFTER DELETE ON public.ci_builds")+ assert.Contains(t, result, "REFERENCING OLD TABLE AS old_table")+ assert.Contains(t, result, "FOR EACH STATEMENT")+ assert.Contains(t, result, "EXECUTE FUNCTION public.loose_foreign_key_on_builds_projects()")+}++func TestTriggerSDLWithComment(t *testing.T) {+ metadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "audit_trigger",+ Body: "CREATE TRIGGER audit_trigger AFTER INSERT ON public.users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ Comment: "Audit log trigger",+ },+ },+ },+ },+ },+ },+ }++ ctx := schema.GetDefinitionContext{+ SDLFormat: true,+ }++ result, err := GetDatabaseDefinition(ctx, metadata)+ require.NoError(t, err)++ assert.Contains(t, result, "CREATE TRIGGER audit_trigger")+ assert.Contains(t, result, "COMMENT ON TRIGGER")+ assert.Contains(t, result, "audit_trigger")+ assert.Contains(t, result, "Audit log trigger")+}++func TestMultipleTriggersSDL(t *testing.T) {+ metadata := &storepb.DatabaseSchemaMetadata{+ Name: "testdb",+ Schemas: []*storepb.SchemaMetadata{+ {+ Name: "public",+ Tables: []*storepb.TableMetadata{+ {+ Name: "users",+ Columns: []*storepb.ColumnMetadata{+ {Name: "id", Type: "integer"},+ },+ Triggers: []*storepb.TriggerMetadata{+ {+ Name: "audit_insert",+ Body: "CREATE TRIGGER audit_insert AFTER INSERT ON public.users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ },+ {+ Name: "audit_update",+ Body: "CREATE TRIGGER audit_update AFTER UPDATE ON public.users FOR EACH ROW EXECUTE FUNCTION audit_log()",+ },+ },+ },+ },+ },+ },+ }++ ctx := schema.GetDefinitionContext{+ SDLFormat: true,+ }++ result, err := GetDatabaseDefinition(ctx, metadata)+ require.NoError(t, err)++ assert.Contains(t, result, "audit_insert")+ assert.Contains(t, result, "audit_update")+}diff --git a/backend/plugin/schema/sdl_differ.go b/backend/plugin/schema/sdl_differ.goindex 8b0c5c8d23..573a0222b3 100644--- a/backend/plugin/schema/sdl_differ.go+++ b/backend/plugin/schema/sdl_differ.go@@ -121,6 +121,7 @@ type SDLChunks struct {Views map[string]*SDLChunk // key: view name/identifierMaterializedViews map[string]*SDLChunk // key: materialized view name/identifierFunctions map[string]*SDLChunk // key: function name/identifier+ Triggers map[string]*SDLChunk // key: schema.table.trigger_name (table-scoped)Indexes map[string]*SDLChunk // key: index name/identifierSequences map[string]*SDLChunk // key: sequence name/identifierSchemas map[string]*SDLChunk // key: schema name/identifier