Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(pg): add PostgreSQL event trigger SDL support (#18212)
rebelice2c24ca33d02a
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.goindex 977dd338a2..e81a956c66 100644--- a/backend/plugin/schema/differ.go+++ b/backend/plugin/schema/differ.go@@ -53,6 +53,9 @@ type MetadataDiff struct {// Extension changesExtensionChanges []*ExtensionDiff+ // Event trigger changes+ EventTriggerChanges []*EventTriggerDiff+// Event changesEventChanges []*EventDiff@@ -277,6 +280,16 @@ type ExtensionDiff struct {NewASTNode any // For SDL/AST-only mode}+// EventTriggerDiff represents changes to an event trigger.+type EventTriggerDiff struct {+ Action MetadataDiffAction+ EventTriggerName string+ OldEventTrigger *storepb.EventTriggerMetadata+ NewEventTrigger *storepb.EventTriggerMetadata+ OldASTNode any // For SDL/AST-only mode+ NewASTNode any // For SDL/AST-only mode+}+// EventDiff represents changes to an event.type EventDiff struct {Action MetadataDiffAction@@ -300,6 +313,7 @@ const (CommentObjectTypeTrigger CommentObjectType = "TRIGGER"CommentObjectTypeType CommentObjectType = "TYPE"CommentObjectTypeExtension CommentObjectType = "EXTENSION"+ CommentObjectTypeEventTrigger CommentObjectType = "EVENT TRIGGER")// CommentDiff represents changes to database object comments.@@ -375,8 +389,9 @@ func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.Da}}- // Compare database-level objects (extensions)+ // Compare database-level objects (extensions, event triggers)compareExtensions(diff, oldMetadata, newMetadata)+ compareEventTriggers(diff, oldMetadata, newMetadata)// Sort all diff lists to ensure stable output ordersortDiffLists(diff)@@ -2033,6 +2048,67 @@ func compareExtensions(diff *MetadataDiff, oldMetadata, newMetadata *storepb.Dat}}+// compareEventTriggers compares event triggers between old and new database metadata.+func compareEventTriggers(diff *MetadataDiff, oldMetadata, newMetadata *storepb.DatabaseSchemaMetadata) {+ // Build maps of event triggers+ oldEventTriggerMap := make(map[string]*storepb.EventTriggerMetadata)+ for _, eventTrigger := range oldMetadata.EventTriggers {+ oldEventTriggerMap[eventTrigger.Name] = eventTrigger+ }++ newEventTriggerMap := make(map[string]*storepb.EventTriggerMetadata)+ for _, eventTrigger := range newMetadata.EventTriggers {+ newEventTriggerMap[eventTrigger.Name] = eventTrigger+ }++ // Check for dropped event triggers+ for name, oldEventTrigger := range oldEventTriggerMap {+ if _, exists := newEventTriggerMap[name]; !exists {+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &EventTriggerDiff{+ Action: MetadataDiffActionDrop,+ EventTriggerName: name,+ OldEventTrigger: oldEventTrigger,+ })+ }+ }++ // Check for new event triggers+ for name, newEventTrigger := range newEventTriggerMap {+ if _, exists := oldEventTriggerMap[name]; !exists {+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &EventTriggerDiff{+ Action: MetadataDiffActionCreate,+ EventTriggerName: name,+ NewEventTrigger: newEventTrigger,+ })+ }+ }++ // Check for modified event triggers+ for name, newEventTrigger := range newEventTriggerMap {+ if oldEventTrigger, exists := oldEventTriggerMap[name]; exists {+ // Check if event trigger has changed+ if oldEventTrigger.Definition != newEventTrigger.Definition ||+ oldEventTrigger.Event != newEventTrigger.Event ||+ oldEventTrigger.FunctionSchema != newEventTrigger.FunctionSchema ||+ oldEventTrigger.FunctionName != newEventTrigger.FunctionName ||+ oldEventTrigger.Enabled != newEventTrigger.Enabled ||+ !slices.Equal(oldEventTrigger.Tags, newEventTrigger.Tags) {+ // Use DROP + CREATE pattern for modifications (no CREATE OR REPLACE for event triggers)+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &EventTriggerDiff{+ Action: MetadataDiffActionDrop,+ EventTriggerName: name,+ OldEventTrigger: oldEventTrigger,+ })+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &EventTriggerDiff{+ Action: MetadataDiffActionCreate,+ EventTriggerName: name,+ NewEventTrigger: newEventTrigger,+ })+ }+ }+ }+}+// compareEvents compares events between old and new schemas.func compareEvents(diff *MetadataDiff, _ string, oldSchema, newSchema *model.SchemaMetadata) {oldSchemaProto := oldSchema.GetProto()@@ -2157,8 +2233,9 @@ func FilterPostgresArchiveSchema(diff *MetadataDiff) *MetadataDiff {}}- // Extensions and Events are database-level objects, not schema-specific, so copy them all+ // Extensions, Event triggers, and Events are database-level objects, not schema-specific, so copy them allfiltered.ExtensionChanges = diff.ExtensionChanges+ filtered.EventTriggerChanges = diff.EventTriggerChangesfiltered.EventChanges = diff.EventChangesreturn filtered@@ -2383,6 +2460,14 @@ func sortDiffLists(diff *MetadataDiff) {return strings.Compare(string(a.Action), string(b.Action))})+ // Sort event trigger changes by event trigger name, then action+ slices.SortFunc(diff.EventTriggerChanges, func(a, b *EventTriggerDiff) int {+ if a.EventTriggerName != b.EventTriggerName {+ return strings.Compare(a.EventTriggerName, b.EventTriggerName)+ }+ return strings.Compare(string(a.Action), string(b.Action))+ })+// Sort event changes by event name, then actionslices.SortFunc(diff.EventChanges, func(a, b *EventDiff) int {if a.EventName != b.EventName {diff --git a/backend/plugin/schema/pg/generate_migration.go b/backend/plugin/schema/pg/generate_migration.goindex 23300a72b6..de45f8cd0d 100644--- a/backend/plugin/schema/pg/generate_migration.go+++ b/backend/plugin/schema/pg/generate_migration.go@@ -51,7 +51,15 @@ func generateMigration(diff *schema.MetadataDiff) (string, error) {// dropObjectsInOrder drops all objects in reverse topological order (most dependent first)func dropObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) {- // First, drop all triggers that might depend on functions we're about to drop+ // Drop event triggers first (before everything else)+ // Event triggers are database-level objects that depend on functions+ for _, etDiff := range diff.EventTriggerChanges {+ if etDiff.Action == schema.MetadataDiffActionDrop {+ writeDropEventTrigger(buf, etDiff.EventTriggerName)+ }+ }++ // Next, drop all triggers that might depend on functions we're about to drop// This is necessary because PostgreSQL doesn't allow dropping functions that are used by triggersfunctionsBeingDropped := make(map[string]bool)for _, funcDiff := range diff.FunctionChanges {@@ -1399,6 +1407,24 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) errorreturn err}+ // Create event triggers (last, as they depend on functions which may have been created)+ for _, etDiff := range diff.EventTriggerChanges {+ if etDiff.Action == schema.MetadataDiffActionCreate {+ // Support both metadata and AST-only modes+ if etDiff.NewEventTrigger != nil {+ // Metadata mode: use event trigger metadata+ if err := writeCreateEventTrigger(buf, etDiff.NewEventTrigger); err != nil {+ return err+ }+ } else if etDiff.NewASTNode != nil {+ // AST-only mode: extract SQL from AST node+ if err := writeMigrationEventTriggerFromAST(buf, etDiff.NewASTNode); err != nil {+ return err+ }+ }+ }+ }+// Handle enum type comment changesif err := generateEnumTypeCommentChanges(buf, diff); err != nil {return err@@ -2170,6 +2196,82 @@ func writeMigrationExtensionFromAST(out *strings.Builder, astNode any) error {return errors.Errorf("unexpected AST node type for extension: %T", astNode)}+func writeDropEventTrigger(out *strings.Builder, eventTriggerName string) {+ _, _ = out.WriteString(`DROP EVENT TRIGGER IF EXISTS "`)+ _, _ = out.WriteString(eventTriggerName)+ _, _ = out.WriteString(`";`)+ _, _ = out.WriteString("\n")+}++func writeCreateEventTrigger(out *strings.Builder, eventTrigger *storepb.EventTriggerMetadata) error {+ // Use the stored definition if available+ if eventTrigger.Definition != "" {+ _, _ = out.WriteString(eventTrigger.Definition)+ _, _ = out.WriteString(";")+ _, _ = out.WriteString("\n")+ return nil+ }++ // Otherwise, build the CREATE EVENT TRIGGER statement+ _, _ = out.WriteString(`CREATE EVENT TRIGGER "`)+ _, _ = out.WriteString(eventTrigger.Name)+ _, _ = out.WriteString(`" ON `)+ _, _ = out.WriteString(eventTrigger.Event)++ // Add WHEN TAG IN clause if tags are specified+ if len(eventTrigger.Tags) > 0 {+ _, _ = out.WriteString("\n WHEN TAG IN (")+ for i, tag := range eventTrigger.Tags {+ if i > 0 {+ _, _ = out.WriteString(", ")+ }+ _, _ = out.WriteString("'")+ _, _ = out.WriteString(tag)+ _, _ = out.WriteString("'")+ }+ _, _ = out.WriteString(")")+ }++ // Add EXECUTE FUNCTION clause+ _, _ = out.WriteString("\n EXECUTE FUNCTION ")+ if eventTrigger.FunctionSchema != "" {+ _, _ = out.WriteString(`"`)+ _, _ = out.WriteString(eventTrigger.FunctionSchema)+ _, _ = out.WriteString(`".`)+ }+ _, _ = out.WriteString(`"`)+ _, _ = out.WriteString(eventTrigger.FunctionName)+ _, _ = out.WriteString(`"()`)+ _, _ = out.WriteString(";")+ _, _ = out.WriteString("\n")++ return nil+}++func writeMigrationEventTriggerFromAST(out *strings.Builder, astNode any) error {+ if astNode == nil {+ return errors.New("AST node is nil")+ }++ // Try to cast to PostgreSQL CreateeventtrigstmtContext+ if ctx, ok := astNode.(*pgparser.CreateeventtrigstmtContext); ok {+ // Get text using token stream+ if stream := ctx.GetParser().GetTokenStream(); stream != nil {+ text := stream.GetTextFromInterval(antlr.Interval{+ Start: ctx.GetStart().GetTokenIndex(),+ Stop: ctx.GetStop().GetTokenIndex(),+ })+ _, _ = out.WriteString(text)+ _, _ = out.WriteString(";")+ _, _ = out.WriteString("\n")+ return nil+ }+ return errors.New("token stream not available for event trigger AST node")+ }++ return errors.Errorf("unexpected AST node type for event trigger: %T", astNode)+}+func writeCreateSchema(out *strings.Builder, schema string) error {_, _ = out.WriteString(`CREATE SCHEMA IF NOT EXISTS "`)_, _ = out.WriteString(schema)@@ -3688,6 +3790,23 @@ func writeCommentOnExtension(out *strings.Builder, extensionName, comment string_, _ = out.WriteString("\n")}+func writeCommentOnEventTrigger(out *strings.Builder, eventTriggerName, comment string) {+ _, _ = out.WriteString(`COMMENT ON EVENT TRIGGER "`)+ _, _ = out.WriteString(eventTriggerName)+ _, _ = 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")+}+func writeCommentOnTrigger(out *strings.Builder, schemaName, tableName, triggerName, comment string) {// Parse table name to get schema and table separatelyparts := strings.Split(tableName, ".")@@ -3847,6 +3966,10 @@ func generateCommentChangesFromSDL(buf *strings.Builder, diff *schema.MetadataDi// COMMENT ON EXTENSIONwriteCommentOnExtension(buf, commentDiff.ObjectName, newComment)+ case schema.CommentObjectTypeEventTrigger:+ // COMMENT ON EVENT TRIGGER+ writeCommentOnEventTrigger(buf, commentDiff.ObjectName, newComment)+case schema.CommentObjectTypeTrigger:// COMMENT ON TRIGGER trigger_name ON table_namewriteCommentOnTrigger(buf, commentDiff.SchemaName, commentDiff.TableName, commentDiff.ObjectName, newComment)diff --git a/backend/plugin/schema/pg/get_database_definition.go b/backend/plugin/schema/pg/get_database_definition.goindex 33881c4051..229b2b8a7e 100644--- a/backend/plugin/schema/pg/get_database_definition.go+++ b/backend/plugin/schema/pg/get_database_definition.go@@ -345,6 +345,17 @@ func GetDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *storepb.Da}}}++ // Construct event triggers (last, as they depend on functions).+ for _, eventTrigger := range metadata.EventTriggers {+ if eventTrigger.SkipDump {+ continue+ }+ if err := writeEventTrigger(&buf, eventTrigger); err != nil {+ return "", err+ }+ }+return buf.String(), nil}@@ -710,7 +721,8 @@ func filterBackupSchemaIfNecessary(ctx schema.GetDefinitionContext, metadata *st}filtered := &storepb.DatabaseSchemaMetadata{- Extensions: metadata.Extensions,+ Extensions: metadata.Extensions,+ EventTriggers: metadata.EventTriggers,}for _, schema := range metadata.Schemas {if schema.Name == common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES) {@@ -779,6 +791,117 @@ func writeTriggerComment(out io.Writer, schema string, table string, trigger *streturn err}+func writeEventTrigger(out io.Writer, eventTrigger *storepb.EventTriggerMetadata) error {+ // Use the stored definition if available+ if eventTrigger.Definition != "" {+ if _, err := io.WriteString(out, eventTrigger.Definition); err != nil {+ return err+ }+ if _, err := io.WriteString(out, ";\n\n"); err != nil {+ return err+ }+ } else {+ // Build the CREATE EVENT TRIGGER statement+ if _, err := io.WriteString(out, `CREATE EVENT TRIGGER "`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, eventTrigger.Name); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `" ON `); err != nil {+ return err+ }+ if _, err := io.WriteString(out, eventTrigger.Event); err != nil {+ return err+ }++ // Add WHEN TAG IN clause if tags are specified+ if len(eventTrigger.Tags) > 0 {+ if _, err := io.WriteString(out, "\n WHEN TAG IN ("); err != nil {+ return err+ }+ for i, tag := range eventTrigger.Tags {+ if i > 0 {+ if _, err := io.WriteString(out, ", "); err != nil {+ return err+ }+ }+ if _, err := io.WriteString(out, "'"); err != nil {+ return err+ }+ if _, err := io.WriteString(out, tag); err != nil {+ return err+ }+ if _, err := io.WriteString(out, "'"); err != nil {+ return err+ }+ }+ if _, err := io.WriteString(out, ")"); err != nil {+ return err+ }+ }++ // Add EXECUTE FUNCTION clause+ if _, err := io.WriteString(out, "\n EXECUTE FUNCTION "); err != nil {+ return err+ }+ if eventTrigger.FunctionSchema != "" {+ if _, err := io.WriteString(out, `"`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, eventTrigger.FunctionSchema); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `".`); err != nil {+ return err+ }+ }+ if _, err := io.WriteString(out, `"`); err != nil {+ return err+ }+ if _, err := io.WriteString(out, eventTrigger.FunctionName); err != nil {+ return err+ }+ if _, err := io.WriteString(out, `"();\n\n`); err != nil {+ return err+ }+ }++ // Write event trigger comment if present+ if eventTrigger.Comment != "" {+ if err := writeEventTriggerComment(out, eventTrigger); err != nil {+ return err+ }+ }++ return nil+}++func writeEventTriggerComment(out io.Writer, eventTrigger *storepb.EventTriggerMetadata) error {+ if _, err := io.WriteString(out, `COMMENT ON EVENT TRIGGER "`); err != nil {+ return err+ }++ if _, err := io.WriteString(out, eventTrigger.Name); err != nil {+ return err+ }++ if _, err := io.WriteString(out, `" IS '`); err != nil {+ return err+ }++ if _, err := io.WriteString(out, escapeSingleQuote(eventTrigger.Comment)); err != nil {+ return err+ }++ if _, err := io.WriteString(out, `';`); err != nil {+ return err+ }++ _, err := io.WriteString(out, "\n\n")+ return err+}+func writeEnum(out io.Writer, schema string, enum *storepb.EnumTypeMetadata) error {if _, err := io.WriteString(out, `CREATE TYPE "`); err != nil {return err@@ -2612,6 +2735,16 @@ func getSDLFormat(metadata *storepb.DatabaseSchemaMetadata) (string, error) {}}+ // Write event triggers (last, as they depend on functions)+ for _, eventTrigger := range metadata.EventTriggers {+ if eventTrigger.SkipDump {+ continue+ }+ if err := writeEventTrigger(&buf, eventTrigger); err != nil {+ return "", err+ }+ }+return buf.String(), nil}@@ -3725,6 +3858,30 @@ func GetMultiFileDatabaseDefinition(ctx schema.GetDefinitionContext, metadata *s})}+ // Generate event_triggers.sql file if there are any event triggers+ if len(metadata.EventTriggers) > 0 {+ var buf strings.Builder+ for i, eventTrigger := range metadata.EventTriggers {+ if eventTrigger.SkipDump {+ continue+ }+ if i > 0 {+ buf.WriteString("\n")+ }++ if err := writeEventTrigger(&buf, eventTrigger); err != nil {+ return nil, errors.Wrapf(err, "failed to generate event trigger SDL for %s", eventTrigger.Name)+ }+ }++ if buf.Len() > 0 {+ files = append(files, schema.File{+ Name: "event_triggers.sql",+ Content: buf.String(),+ })+ }+ }+return &schema.MultiFileSchemaResult{Files: files}, nil}diff --git a/backend/plugin/schema/pg/get_sdl_diff.go b/backend/plugin/schema/pg/get_sdl_diff.goindex cb15fa5e02..0d6fa0966b 100644--- a/backend/plugin/schema/pg/get_sdl_diff.go+++ b/backend/plugin/schema/pg/get_sdl_diff.go@@ -109,6 +109,9 @@ func GetSDLDiff(currentSDLText, previousUserSDLText string, currentSchema, previ// Process extension changesprocessExtensionChanges(currentChunks, previousChunks, currentDBSDLChunks, diff)+ // Process event trigger changes+ processEventTriggerChanges(currentChunks, previousChunks, currentDBSDLChunks, diff)+// Process explicit schema changes (CREATE SCHEMA statements)processSchemaChanges(currentChunks, previousChunks, currentSchema, diff)@@ -135,6 +138,7 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {Schemas: make(map[string]*schema.SDLChunk),EnumTypes: make(map[string]*schema.SDLChunk),Extensions: make(map[string]*schema.SDLChunk),+ EventTriggers: make(map[string]*schema.SDLChunk),ColumnComments: make(map[string]map[string]antlr.ParserRuleContext),IndexComments: make(map[string]map[string]antlr.ParserRuleContext),}, nil@@ -158,6 +162,7 @@ func ChunkSDLText(sdlText string) (*schema.SDLChunks, error) {Schemas: make(map[string]*schema.SDLChunk),EnumTypes: make(map[string]*schema.SDLChunk),Extensions: make(map[string]*schema.SDLChunk),+ EventTriggers: make(map[string]*schema.SDLChunk),ColumnComments: make(map[string]map[string]antlr.ParserRuleContext),IndexComments: make(map[string]map[string]antlr.ParserRuleContext),},@@ -504,6 +509,23 @@ func (l *sdlChunkExtractor) EnterCreateextensionstmt(ctx *parser.Createextensionl.chunks.Extensions[extensionName] = chunk}+func (l *sdlChunkExtractor) EnterCreateeventtrigstmt(ctx *parser.CreateeventtrigstmtContext) {+ // Extract event trigger name from AST+ if ctx.Name() == nil {+ return+ }++ eventTriggerName := pgparser.NormalizePostgreSQLName(ctx.Name())++ // Event trigger is database-level, no schema prefix needed+ chunk := &schema.SDLChunk{+ Identifier: eventTriggerName, // Just the event trigger name+ ASTNode: ctx,+ }++ l.chunks.EventTriggers[eventTriggerName] = chunk+}+func (l *sdlChunkExtractor) EnterCommentstmt(ctx *parser.CommentstmtContext) {// Extract the comment text (can be sconst or NULL)// We store the entire AST node, not just the comment text@@ -750,6 +772,18 @@ func (l *sdlChunkExtractor) EnterCommentstmt(ctx *parser.CommentstmtContext) {}l.chunks.Extensions[name] = chunk}+ case "EVENTTRIGGER", "EVENT TRIGGER":+ // Event triggers are database-level, no schema prefix+ if chunk, exists := l.chunks.EventTriggers[name]; exists {+ chunk.CommentStatements = append(chunk.CommentStatements, ctx)+ } else {+ chunk := &schema.SDLChunk{+ Identifier: name,+ ASTNode: nil,+ CommentStatements: []antlr.ParserRuleContext{ctx},+ }+ l.chunks.EventTriggers[name] = chunk+ }default:// Other object types are handled elsewhere}@@ -3780,6 +3814,14 @@ func buildCurrentDatabaseSDLChunks(currentSchema *model.DatabaseMetadata) (*currsdlChunks.comments[extensionName] = []string{commentText}}}+ for eventTriggerName, chunk := range currentSDLChunks.EventTriggers {+ sdlChunks.chunks[eventTriggerName] = strings.TrimSpace(chunk.GetTextWithoutComments())+ // Store comment text for usability check+ commentText := extractCommentTextFromChunk(chunk)+ if commentText != "" {+ sdlChunks.comments[eventTriggerName] = []string{commentText}+ }+ }return sdlChunks, nil}@@ -5732,6 +5774,7 @@ func processCommentChanges(currentChunks, previousChunks *schema.SDLChunks, currprocessObjectComments(currentChunks.EnumTypes, previousChunks.EnumTypes, schema.CommentObjectTypeType, createdObjects, droppedObjects, currentDBSDLChunks, diff)processObjectComments(currentChunks.Indexes, previousChunks.Indexes, schema.CommentObjectTypeIndex, createdObjects, droppedObjects, currentDBSDLChunks, diff)processObjectComments(currentChunks.Schemas, previousChunks.Schemas, schema.CommentObjectTypeSchema, createdObjects, droppedObjects, currentDBSDLChunks, diff)+ processObjectComments(currentChunks.EventTriggers, previousChunks.EventTriggers, schema.CommentObjectTypeEventTrigger, createdObjects, droppedObjects, currentDBSDLChunks, diff)// Process column commentsprocessColumnComments(currentChunks, previousChunks, createdObjects, droppedObjects, diff)@@ -5790,6 +5833,13 @@ func buildCreatedObjectsSet(diff *schema.MetadataDiff) map[string]bool {}}+ for _, etDiff := range diff.EventTriggerChanges {+ if etDiff.Action == schema.MetadataDiffActionCreate {+ // Event triggers are database-level, no schema prefix+ created[etDiff.EventTriggerName] = true+ }+ }+return created}@@ -5846,6 +5896,13 @@ func buildDroppedObjectsSet(diff *schema.MetadataDiff) map[string]bool {}}+ for _, etDiff := range diff.EventTriggerChanges {+ if etDiff.Action == schema.MetadataDiffActionDrop {+ // Event triggers are database-level, no schema prefix+ dropped[etDiff.EventTriggerName] = true+ }+ }+return dropped}@@ -5878,14 +5935,14 @@ func processObjectComments(currentMap, previousMap map[string]*schema.SDLChunk,}var schemaName, objectName string- // For SCHEMA and EXTENSION objects, identifier is just the object name (database-level)+ // For SCHEMA, EXTENSION, and EVENT TRIGGER objects, identifier is just the object name (database-level)// For other objects, identifier is "schema.object"switch objectType {case schema.CommentObjectTypeSchema:schemaName = identifierobjectName = identifier // For schemas, objectName is also the schema name- case schema.CommentObjectTypeExtension:- schemaName = "" // Extensions are database-level, no schema+ case schema.CommentObjectTypeExtension, schema.CommentObjectTypeEventTrigger:+ schemaName = "" // Extensions and event triggers are database-level, no schemaobjectName = identifierdefault:schemaName, objectName = parseIdentifier(identifier)@@ -7145,6 +7202,85 @@ func processExtensionChanges(currentChunks, previousChunks *schema.SDLChunks, cu}}+// processEventTriggerChanges processes event trigger changes between current and previous chunks+func processEventTriggerChanges(currentChunks, previousChunks *schema.SDLChunks, currentDBSDLChunks *currentDatabaseSDLChunks, diff *schema.MetadataDiff) {+ // Process current event triggers to find created and modified ones+ for eventTriggerName, currentChunk := range currentChunks.EventTriggers {+ if previousChunk, exists := previousChunks.EventTriggers[eventTriggerName]; exists {+ // Event trigger exists in both - check if modified by comparing text (excluding comments)+ currentText := currentChunk.GetTextWithoutComments()+ previousText := previousChunk.GetTextWithoutComments()+ if currentText != previousText {+ // Apply usability check+ if currentDBSDLChunks.shouldSkipChunkDiffForUsability(currentText, eventTriggerName) {+ continue+ }+ // Event trigger was modified - use DROP + CREATE pattern+ // (PostgreSQL doesn't support CREATE OR REPLACE for event triggers)+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &schema.EventTriggerDiff{+ Action: schema.MetadataDiffActionDrop,+ EventTriggerName: eventTriggerName,+ OldEventTrigger: nil,+ NewEventTrigger: nil,+ OldASTNode: previousChunk.ASTNode,+ NewASTNode: nil,+ })+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &schema.EventTriggerDiff{+ Action: schema.MetadataDiffActionCreate,+ EventTriggerName: eventTriggerName,+ OldEventTrigger: nil,+ NewEventTrigger: nil,+ OldASTNode: nil,+ NewASTNode: currentChunk.ASTNode,+ })+ }+ // Note: Comment-only changes are handled by processCommentChanges+ } else {+ // Event trigger is new in current SDL+ currentText := currentChunk.GetTextWithoutComments()+ // Apply usability check+ if currentDBSDLChunks.shouldSkipChunkDiffForUsability(currentText, eventTriggerName) {+ continue+ }+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &schema.EventTriggerDiff{+ Action: schema.MetadataDiffActionCreate,+ EventTriggerName: eventTriggerName,+ OldEventTrigger: nil,+ NewEventTrigger: nil,+ OldASTNode: nil,+ NewASTNode: currentChunk.ASTNode,+ })+ // Handle comments for new event triggers+ if len(currentChunk.CommentStatements) > 0 {+ for _, commentNode := range currentChunk.CommentStatements {+ diff.CommentChanges = append(diff.CommentChanges, &schema.CommentDiff{+ Action: schema.MetadataDiffActionCreate,+ ObjectType: schema.CommentObjectTypeEventTrigger,+ ObjectName: eventTriggerName,+ NewComment: extractTextFromNode(commentNode),+ NewASTNode: commentNode,+ })+ }+ }+ }+ }++ // Process previous event triggers to find dropped ones+ for eventTriggerName, previousChunk := range previousChunks.EventTriggers {+ if _, exists := currentChunks.EventTriggers[eventTriggerName]; !exists {+ // Event trigger was dropped+ diff.EventTriggerChanges = append(diff.EventTriggerChanges, &schema.EventTriggerDiff{+ Action: schema.MetadataDiffActionDrop,+ EventTriggerName: eventTriggerName,+ OldEventTrigger: nil,+ NewEventTrigger: nil,+ OldASTNode: previousChunk.ASTNode,+ NewASTNode: nil,+ })+ }+ }+}+// processSchemaChanges processes explicit CREATE SCHEMA statements in the SDLfunc processSchemaChanges(currentChunks, previousChunks *schema.SDLChunks, currentMeta *model.DatabaseMetadata, diff *schema.MetadataDiff) {// Build set of existing schemas in current databasediff --git a/backend/plugin/schema/sdl_differ.go b/backend/plugin/schema/sdl_differ.goindex 573a0222b3..dbbb5a068b 100644--- a/backend/plugin/schema/sdl_differ.go+++ b/backend/plugin/schema/sdl_differ.go@@ -127,6 +127,7 @@ type SDLChunks struct {Schemas map[string]*SDLChunk // key: schema name/identifierEnumTypes map[string]*SDLChunk // key: enum type name/identifierExtensions map[string]*SDLChunk // key: extension name/identifier+ EventTriggers map[string]*SDLChunk // key: event trigger name (database-level, no schema)// Column comments: map[schemaName.tableName][columnName] -> COMMENT ON COLUMN AST nodeColumnComments map[string]map[string]antlr.ParserRuleContext