Skip to content

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

feat: add PostgreSQL trigger support for SDL mode (#18130)

rebelice5231e700e5ac
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.go
index 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 CommentObjectType
SchemaName string
+ TableName string // used for TRIGGER comments (COMMENT ON TRIGGER trigger_name ON table_name)
ObjectName string // table/view/function/sequence/index name
ColumnName string // only used for COLUMN comments
IndexName string // only used for table-level INDEX comments
@@ -1396,8 +1403,9 @@ func compareTriggers(oldTriggers, newTriggers []*storepb.TriggerMetadata) []*Tri
for 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) []*Tri
oldTrigger, 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 altering
changes = 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.go
index 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 tables
for _, 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 dropped
for _, 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 dropped
for _, 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 constraints
for _, 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 generateDrops
for _, 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 itself
if 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 constraints
for _, 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 order
orderedList, err := graph.TopologicalSort()
if err != nil {
@@ -1086,6 +1155,13 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error
if (funcDiff.Action == schema.MetadataDiffActionCreate || funcDiff.Action == schema.MetadataDiffActionAlter) && funcDiff.NewFunction != nil && funcDiff.NewFunction.Comment != "" {
writeCommentOnFunction(buf, funcDiff.SchemaName, funcDiff.NewFunction.Signature, funcDiff.NewFunction.Comment, funcDiff.NewASTNode, funcDiff.NewFunction.Definition)
}
+ } else if triggerDiff, ok := triggerMap[objID]; ok {
+ // Handle triggers (both CREATE and ALTER use CREATE OR REPLACE)
+ if triggerDiff.Action == schema.MetadataDiffActionCreate || triggerDiff.Action == schema.MetadataDiffActionAlter {
+ 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 TriggerChanges
for _, tableDiff := range tableMap {
if tableDiff.Action == schema.MetadataDiffActionCreate && tableDiff.NewTable != nil {
+ // Only create triggers that weren't already created from TriggerChanges
+ triggersInChanges := make(map[string]bool)
+ for _, triggerDiff := range tableDiff.TriggerChanges {
+ if triggerDiff.Action == schema.MetadataDiffActionCreate {
+ triggersInChanges[triggerDiff.TriggerName] = true
+ }
+ }
+
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.Builder
for _, 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 EXTENSION
writeCommentOnExtension(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, skip
continue
@@ -4412,3 +4540,261 @@ func extractForeignKeysFromAST(createStmt *pgparser.CreatestmtContext, defaultSc
return 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.go
index 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 table
for _, 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.go
index 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 changes
processViewChanges(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, currentSchema
return 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 metadata
err = 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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/identifier
MaterializedViews map[string]*SDLChunk // key: materialized view name/identifier
Functions 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/identifier
Sequences map[string]*SDLChunk // key: sequence name/identifier
Schemas map[string]*SDLChunk // key: schema name/identifier