Skip to content

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

feat(pg): add PostgreSQL event trigger SDL support (#18212)

rebelice2c24ca33d02a
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.go
index 977dd338a2..e81a956c66 100644
--- a/backend/plugin/schema/differ.go
+++ b/backend/plugin/schema/differ.go
@@ -53,6 +53,9 @@ type MetadataDiff struct {
// Extension changes
ExtensionChanges []*ExtensionDiff
+ // Event trigger changes
+ EventTriggerChanges []*EventTriggerDiff
+
// Event changes
EventChanges []*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 order
sortDiffLists(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 all
filtered.ExtensionChanges = diff.ExtensionChanges
+ filtered.EventTriggerChanges = diff.EventTriggerChanges
filtered.EventChanges = diff.EventChanges
return 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 action
slices.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.go
index 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 triggers
functionsBeingDropped := make(map[string]bool)
for _, funcDiff := range diff.FunctionChanges {
@@ -1399,6 +1407,24 @@ func createObjectsInOrder(diff *schema.MetadataDiff, buf *strings.Builder) error
return 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 changes
if 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 separately
parts := strings.Split(tableName, ".")
@@ -3847,6 +3966,10 @@ func generateCommentChangesFromSDL(buf *strings.Builder, diff *schema.MetadataDi
// COMMENT ON EXTENSION
writeCommentOnExtension(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_name
writeCommentOnTrigger(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.go
index 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 *st
return 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.go
index 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 changes
processExtensionChanges(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.Createextension
l.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) (*curr
sdlChunks.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, curr
processObjectComments(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 comments
processColumnComments(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 = identifier
objectName = 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 schema
objectName = identifier
default:
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 SDL
func processSchemaChanges(currentChunks, previousChunks *schema.SDLChunks, currentMeta *model.DatabaseMetadata, diff *schema.MetadataDiff) {
// Build set of existing schemas in current database
diff --git a/backend/plugin/schema/sdl_differ.go b/backend/plugin/schema/sdl_differ.go
index 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/identifier
EnumTypes map[string]*SDLChunk // key: enum type name/identifier
Extensions 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 node
ColumnComments map[string]map[string]antlr.ParserRuleContext