From 3d1e87e5bca15b1941821284dd83a8fa24ee3954 Mon Sep 17 00:00:00 2001 From: Daylon Wilkins Date: Fri, 25 Apr 2025 03:53:24 -0700 Subject: [PATCH] Added support for triggers --- .github/workflows/regression-tests.yml | 4 +- core/context.go | 35 + core/functions/collection.go | 18 +- core/id/id.go | 2 + core/id/id_wrappers.go | 32 + core/id/table.go | 29 + core/rootobject/collection.go | 2 + core/rootobject/objinterface/interfaces.go | 1 + core/triggers/collection.go | 380 + core/triggers/collection_funcs.go | 109 + core/triggers/root_object.go | 118 + core/triggers/serialization.go | 96 + flatbuffers/gen/serial/rootvalue.go | 42 +- flatbuffers/serial/rootvalue.fbs | 2 + postgres/parser/sem/tree/name_part.go | 5 + server/analyzer/assign_triggers.go | 208 + server/analyzer/init.go | 2 + server/ast/create_function.go | 7 +- server/ast/create_trigger.go | 69 +- server/expression/statement_runner.go | 74 + .../framework/interpreted_function.go | 11 +- server/node/create_trigger.go | 199 + server/node/trigger_execution.go | 231 + server/plpgsql/interpreter_logic.go | 38 +- server/plpgsql/interpreter_stack.go | 105 +- server/plpgsql/json.go | 24 +- server/plpgsql/json_convert.go | 22 +- server/plpgsql/parse.go | 2 +- server/plpgsql/statements.go | 59 +- server/transform/node.go | 13 +- server/types/globals.go | 2 +- server/types/trigger.go | 55 + .../output/create_trigger_test.go | 15108 ++++++++-------- testing/go/create_function_test.go | 15 +- testing/go/trigger_test.go | 527 +- 35 files changed, 10021 insertions(+), 7625 deletions(-) create mode 100644 core/id/table.go create mode 100644 core/triggers/collection.go create mode 100644 core/triggers/collection_funcs.go create mode 100644 core/triggers/root_object.go create mode 100644 core/triggers/serialization.go create mode 100644 server/analyzer/assign_triggers.go create mode 100644 server/expression/statement_runner.go create mode 100644 server/node/create_trigger.go create mode 100644 server/node/trigger_execution.go create mode 100644 server/types/trigger.go diff --git a/.github/workflows/regression-tests.yml b/.github/workflows/regression-tests.yml index f8fbc0e861..6fa3b68434 100644 --- a/.github/workflows/regression-tests.yml +++ b/.github/workflows/regression-tests.yml @@ -52,7 +52,7 @@ jobs: cd testing/go/regression mkdir -p out cd tool - go test --timeout=20m ./... --count=1 + go test --timeout=90m ./... --count=1 cp ../out/results.trackers ../out/results2.trackers - name: Test main branch @@ -66,7 +66,7 @@ jobs: cd testing/go/regression mkdir -p out cd tool - go test --timeout=20m ./... --count=1 + go test --timeout=90m ./... --count=1 cp ../out/results.trackers ../out/results1.trackers - name: Check result trackers diff --git a/core/context.go b/core/context.go index 06f174f474..8c5102fb16 100644 --- a/core/context.go +++ b/core/context.go @@ -23,6 +23,7 @@ import ( "github.com/dolthub/doltgresql/core/functions" "github.com/dolthub/doltgresql/core/sequences" + "github.com/dolthub/doltgresql/core/triggers" "github.com/dolthub/doltgresql/core/typecollection" ) @@ -33,6 +34,7 @@ type contextValues struct { seqs *sequences.Collection types *typecollection.TypeCollection funcs *functions.Collection + trigs *triggers.Collection pgCatalogCache any } @@ -244,6 +246,31 @@ func GetSequencesCollectionFromContext(ctx *sql.Context) (*sequences.Collection, return cv.seqs, nil } +// GetTriggersCollectionFromContext returns the triggers collection from the given context. Will always return a +// collection if no error is returned. +func GetTriggersCollectionFromContext(ctx *sql.Context) (*triggers.Collection, error) { + cv, err := getContextValues(ctx) + if err != nil { + return nil, err + } + _, root, err := getRootFromContext(ctx) + if err != nil { + return nil, err + } + if cv.trigs == nil { + cv.trigs, err = triggers.LoadTriggers(ctx, root) + if err != nil { + return nil, err + } + } else if cv.trigs.DiffersFrom(ctx, root) { + cv.trigs, err = triggers.LoadTriggers(ctx, root) + if err != nil { + return nil, err + } + } + return cv.trigs, nil +} + // GetTypesCollectionFromContext returns the given type collection from the context. // Will always return a collection if no error is returned. func GetTypesCollectionFromContext(ctx *sql.Context) (*typecollection.TypeCollection, error) { @@ -296,6 +323,14 @@ func CloseContextRootFinalizer(ctx *sql.Context) error { newRoot = retRoot.(*RootValue) cv.funcs = nil } + if cv.trigs != nil && cv.trigs.DiffersFrom(ctx, root) { + retRoot, err := cv.trigs.UpdateRoot(ctx, newRoot) + if err != nil { + return err + } + newRoot = retRoot.(*RootValue) + cv.trigs = nil + } if cv.types != nil { retRoot, err := cv.types.UpdateRoot(ctx, newRoot) if err != nil { diff --git a/core/functions/collection.go b/core/functions/collection.go index be0b8878ed..b386469448 100644 --- a/core/functions/collection.go +++ b/core/functions/collection.go @@ -18,6 +18,7 @@ import ( "context" "fmt" "maps" + "slices" "strings" "github.com/cockroachdb/errors" @@ -268,6 +269,7 @@ func (pgf *Collection) Clone(ctx context.Context) *Collection { return &Collection{ accessCache: maps.Clone(pgf.accessCache), overloadCache: maps.Clone(pgf.overloadCache), + idCache: slices.Clone(pgf.idCache), underlyingMap: pgf.underlyingMap, mapHash: pgf.mapHash, ns: pgf.ns, @@ -286,7 +288,15 @@ func (pgf *Collection) DiffersFrom(ctx context.Context, root objinterface.RootVa if err != nil { return true } - return !pgf.mapHash.Equal(hashOnGivenRoot) + if pgf.mapHash.Equal(hashOnGivenRoot) { + return false + } + // An empty map should match an uninitialized collection on the root + count, err := pgf.underlyingMap.Count() + if err == nil && count == 0 && hashOnGivenRoot.IsEmpty() { + return false + } + return true } // reloadCaches writes the underlying map's contents to the caches. @@ -353,12 +363,12 @@ func (pgf *Collection) tableNameToID(schemaName string, formattedName string) id return id.NewFunction(schemaName, functionName, typeIDs...) } -// GetID implements the interface rootobject.RootObject. +// GetID implements the interface objinterface.RootObject. func (function Function) GetID() objinterface.RootObjectID { return objinterface.RootObjectID_Functions } -// HashOf implements the interface rootobject.RootObject. +// HashOf implements the interface objinterface.RootObject. func (function Function) HashOf(ctx context.Context) (hash.Hash, error) { data, err := function.Serialize(ctx) if err != nil { @@ -367,7 +377,7 @@ func (function Function) HashOf(ctx context.Context) (hash.Hash, error) { return hash.Of(data), nil } -// Name implements the interface rootobject.RootObject. +// Name implements the interface objinterface.RootObject. func (function Function) Name() doltdb.TableName { return FunctionIDToTableName(function.ID) } diff --git a/core/id/id.go b/core/id/id.go index 25c6b8a40a..9a1d0e32d7 100644 --- a/core/id/id.go +++ b/core/id/id.go @@ -71,6 +71,8 @@ const ( NullSequence Sequence = "" // NullTable is an empty, invalid ID. This is exactly equivalent to Null. NullTable Table = "" + // NullTrigger is an empty, invalid ID. This is exactly equivalent to Null. + NullTrigger Trigger = "" // NullType is an empty, invalid ID. This is exactly equivalent to Null. NullType Type = "" // NullView is an empty, invalid ID. This is exactly equivalent to Null. diff --git a/core/id/id_wrappers.go b/core/id/id_wrappers.go index 2525efa2f7..de9dbe51e6 100644 --- a/core/id/id_wrappers.go +++ b/core/id/id_wrappers.go @@ -55,6 +55,9 @@ type Sequence Id // Table is an Id wrapper for tables. This wrapper must not be returned to the client. type Table Id +// Trigger is an Id wrapper for triggers. This wrapper must not be returned to the client. +type Trigger Id + // Type is an Id wrapper for types. This wrapper must not be returned to the client. type Type Id @@ -168,6 +171,14 @@ func NewTable(schemaName string, tableName string) Table { return Table(NewId(Section_Table, schemaName, tableName)) } +// NewTrigger returns a new Trigger. This wrapper must not be returned to the client. +func NewTrigger(schemaName string, tableName string, triggerName string) Trigger { + if len(schemaName) == 0 && len(tableName) == 0 && len(triggerName) == 0 { + return NullTrigger + } + return Trigger(NewId(Section_Trigger, schemaName, tableName, triggerName)) +} + // NewType returns a new Type. This wrapper must not be returned to the client. func NewType(schemaName string, typeName string) Type { if len(schemaName) == 0 && len(typeName) == 0 { @@ -330,6 +341,21 @@ func (id Table) TableName() string { return Id(id).Segment(1) } +// SchemaName returns the schema name of the trigger. +func (id Trigger) SchemaName() string { + return Id(id).Segment(0) +} + +// TableName returns the name of the table that the trigger belongs to. +func (id Trigger) TableName() string { + return Id(id).Segment(1) +} + +// TriggerName returns the trigger's name. +func (id Trigger) TriggerName() string { + return Id(id).Segment(2) +} + // SchemaName returns the schema name of the type. func (id Type) SchemaName() string { return Id(id).Segment(0) @@ -389,6 +415,9 @@ func (id Sequence) IsValid() bool { return Id(id).IsValid() } // IsValid returns whether the ID is valid. func (id Table) IsValid() bool { return Id(id).IsValid() } +// IsValid returns whether the ID is valid. +func (id Trigger) IsValid() bool { return Id(id).IsValid() } + // IsValid returns whether the ID is valid. func (id Type) IsValid() bool { return Id(id).IsValid() } @@ -434,6 +463,9 @@ func (id Sequence) AsId() Id { return Id(id) } // AsId returns the unwrapped ID. func (id Table) AsId() Id { return Id(id) } +// AsId returns the unwrapped ID. +func (id Trigger) AsId() Id { return Id(id) } + // AsId returns the unwrapped ID. func (id Type) AsId() Id { return Id(id) } diff --git a/core/id/table.go b/core/id/table.go new file mode 100644 index 0000000000..a1593c1339 --- /dev/null +++ b/core/id/table.go @@ -0,0 +1,29 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package id + +import ( + "github.com/cockroachdb/errors" + "github.com/dolthub/go-mysql-server/sql" +) + +// GetFromTable returns the id from the table. +func GetFromTable(ctx *sql.Context, tbl sql.Table) (Table, bool, error) { + schTbl, ok := tbl.(sql.DatabaseSchemaTable) + if !ok { + return NullTable, false, errors.Newf(`table "%s" does not specify a schema`, tbl.Name()) + } + return NewTable(schTbl.DatabaseSchema().SchemaName(), schTbl.Name()), true, nil +} diff --git a/core/rootobject/collection.go b/core/rootobject/collection.go index c2504efe7a..11cb1ecae6 100644 --- a/core/rootobject/collection.go +++ b/core/rootobject/collection.go @@ -26,6 +26,7 @@ import ( "github.com/dolthub/doltgresql/core/id" "github.com/dolthub/doltgresql/core/rootobject/objinterface" "github.com/dolthub/doltgresql/core/sequences" + "github.com/dolthub/doltgresql/core/triggers" "github.com/dolthub/doltgresql/core/typecollection" ) @@ -36,6 +37,7 @@ var ( &sequences.Collection{}, &typecollection.TypeCollection{}, &functions.Collection{}, + &triggers.Collection{}, } ) diff --git a/core/rootobject/objinterface/interfaces.go b/core/rootobject/objinterface/interfaces.go index a0a5e288cf..57d9af9879 100644 --- a/core/rootobject/objinterface/interfaces.go +++ b/core/rootobject/objinterface/interfaces.go @@ -33,6 +33,7 @@ const ( RootObjectID_Sequences RootObjectID_Types RootObjectID_Functions + RootObjectID_Triggers ) // Collection is a collection of root objects. diff --git a/core/triggers/collection.go b/core/triggers/collection.go new file mode 100644 index 0000000000..1d2571940d --- /dev/null +++ b/core/triggers/collection.go @@ -0,0 +1,380 @@ +// Copyright 2024 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package triggers + +import ( + "context" + "fmt" + "maps" + "slices" + "sort" + "strings" + + "github.com/cockroachdb/errors" + "github.com/dolthub/dolt/go/libraries/doltcore/doltdb" + "github.com/dolthub/dolt/go/store/hash" + "github.com/dolthub/dolt/go/store/prolly" + "github.com/dolthub/dolt/go/store/prolly/tree" + "github.com/dolthub/go-mysql-server/sql" + + "github.com/dolthub/doltgresql/core/id" + "github.com/dolthub/doltgresql/core/rootobject/objinterface" +) + +// Collection contains a collection of triggers. +type Collection struct { + accessCache map[id.Trigger]Trigger // This cache is used for general access when you know the exact ID + tableCache map[id.Table][]id.Trigger // This cache is used to find triggers by table + idCache []id.Trigger // This cache simply contains the name of every trigger + mapHash hash.Hash // This is cached so that we don't have to calculate the hash every time + underlyingMap prolly.AddressMap + ns tree.NodeStore +} + +// TriggerTiming specifies the timing of the trigger's execution. +type TriggerTiming uint8 + +const ( + TriggerTiming_Before TriggerTiming = 0 + TriggerTiming_After TriggerTiming = 1 + TriggerTiming_InsteadOf TriggerTiming = 2 +) + +// TriggerDeferrable specifies whether the trigger is deferrable. +type TriggerDeferrable uint8 + +const ( + TriggerDeferrable_NotDeferrable TriggerDeferrable = 0 // NOT DEFERRABLE + TriggerDeferrable_DeferrableImmediate TriggerDeferrable = 1 // DEFERRABLE INITIALLY IMMEDIATE + TriggerDeferrable_DeferrableDeferred TriggerDeferrable = 2 // DEFERRABLE INITIALLY DEFERRED +) + +// TriggerEventType specifies which type of event that the trigger applies to. +type TriggerEventType uint8 + +const ( + TriggerEventType_Insert TriggerEventType = 0 + TriggerEventType_Update TriggerEventType = 1 + TriggerEventType_Delete TriggerEventType = 2 + TriggerEventType_Truncate TriggerEventType = 3 +) + +// TriggerEvent specifies the event type, along with column information for update events. +type TriggerEvent struct { + Type TriggerEventType + ColumnNames []string +} + +// Trigger represents a trigger. +type Trigger struct { + ID id.Trigger + Function id.Function + Timing TriggerTiming + Events []TriggerEvent + ForEachRow bool // When false, represents FOR EACH STATEMENT + When sql.Expression // TODO: should this be PLpgSQL operations? + Deferrable TriggerDeferrable + ReferencedTableName id.Table // FROM referenced_table_name + Constraint bool + OldTransitionName string // REFERENCING OLD TABLE AS transition_relation_name + NewTransitionName string // REFERENCING NEW TABLE AS transition_relation_name + Arguments []string + Definition string +} + +var _ objinterface.Collection = (*Collection)(nil) +var _ objinterface.RootObject = Trigger{} + +// NewCollection returns a new Collection. +func NewCollection(ctx context.Context, underlyingMap prolly.AddressMap, ns tree.NodeStore) (*Collection, error) { + collection := &Collection{ + accessCache: make(map[id.Trigger]Trigger), + tableCache: make(map[id.Table][]id.Trigger), + idCache: nil, + mapHash: hash.Hash{}, + underlyingMap: underlyingMap, + ns: ns, + } + return collection, collection.reloadCaches(ctx) +} + +// GetTrigger returns the trigger with the given ID. Returns a trigger with an invalid ID if it cannot be found +// (Trigger.ID.IsValid() == false). +func (pgt *Collection) GetTrigger(ctx context.Context, trigID id.Trigger) (Trigger, error) { + if f, ok := pgt.accessCache[trigID]; ok { + return f, nil + } + return Trigger{}, nil +} + +// GetTriggerIDsForTable returns the trigger IDs for the given table. +func (pgt *Collection) GetTriggerIDsForTable(ctx context.Context, tableID id.Table) []id.Trigger { + return pgt.tableCache[tableID] +} + +// GetTriggersForTable returns the triggers for the given table. +func (pgt *Collection) GetTriggersForTable(ctx context.Context, tableID id.Table) []Trigger { + triggerIDs := pgt.tableCache[tableID] + triggers := make([]Trigger, len(triggerIDs)) + for i, trigID := range triggerIDs { + triggers[i] = pgt.accessCache[trigID] + } + return triggers +} + +// GetTriggersForTableByTiming returns the triggers for the given table, all matching the given timing. These triggers +// are also sorted by their name ascending. +func (pgt *Collection) GetTriggersForTableByTiming(ctx context.Context, tableID id.Table, timing TriggerTiming) []Trigger { + triggers := pgt.GetTriggersForTable(ctx, tableID) + timingTriggers := make([]Trigger, 0, len(triggers)) + for _, trig := range triggers { + if trig.Timing == timing { + timingTriggers = append(timingTriggers, trig) + } + } + sort.Slice(timingTriggers, func(i, j int) bool { + return timingTriggers[i].Name().String() < timingTriggers[j].Name().String() + }) + return timingTriggers +} + +// HasTrigger returns whether the trigger is present. +func (pgt *Collection) HasTrigger(ctx context.Context, trigID id.Trigger) bool { + _, ok := pgt.accessCache[trigID] + return ok +} + +// AddTrigger adds a new trigger. +func (pgt *Collection) AddTrigger(ctx context.Context, t Trigger) error { + // First we'll check to see if it exists + if _, ok := pgt.accessCache[t.ID]; ok { + return errors.Errorf(`trigger "%s" for relation "%s" already exists`, t.ID.TriggerName(), t.ID.TableName()) + } + + // Now we'll add the trigger to our map + data, err := t.Serialize(ctx) + if err != nil { + return err + } + h, err := pgt.ns.WriteBytes(ctx, data) + if err != nil { + return err + } + mapEditor := pgt.underlyingMap.Editor() + if err = mapEditor.Add(ctx, string(t.ID), h); err != nil { + return err + } + newMap, err := mapEditor.Flush(ctx) + if err != nil { + return err + } + pgt.underlyingMap = newMap + pgt.mapHash = pgt.underlyingMap.HashOf() + return pgt.reloadCaches(ctx) +} + +// DropTrigger drops an existing trigger. +func (pgt *Collection) DropTrigger(ctx context.Context, trigIDs ...id.Trigger) error { + if len(trigIDs) == 0 { + return nil + } + // Check that each name exists before performing any deletions + for _, trigID := range trigIDs { + if _, ok := pgt.accessCache[trigID]; !ok { + return errors.Errorf(`trigger "%s" for table "%s" does not exist`, trigID.TriggerName(), trigID.TableName()) + } + } + + // Now we'll remove the triggers from the map + mapEditor := pgt.underlyingMap.Editor() + for _, trigID := range trigIDs { + err := mapEditor.Delete(ctx, string(trigID)) + if err != nil { + return err + } + } + newMap, err := mapEditor.Flush(ctx) + if err != nil { + return err + } + pgt.underlyingMap = newMap + pgt.mapHash = pgt.underlyingMap.HashOf() + return pgt.reloadCaches(ctx) +} + +// resolveName returns the fully resolved name of the given trigger. Returns an error if the name is ambiguous. +func (pgt *Collection) resolveName(ctx context.Context, schemaName string, formattedName string) (id.Trigger, error) { + if len(pgt.accessCache) == 0 || len(formattedName) == 0 { + return id.NullTrigger, nil + } + + // Check for an exact match + fullID := pgt.tableNameToID(schemaName, formattedName) + if _, ok := pgt.accessCache[fullID]; ok { + return fullID, nil + } + tableName := fullID.TableName() + triggerName := fullID.TriggerName() + + // Otherwise we'll iterate over all the names + var resolvedID id.Trigger + for _, trigID := range pgt.idCache { + if !strings.EqualFold(triggerName, trigID.TriggerName()) || !strings.EqualFold(tableName, trigID.TableName()) { + continue + } + if len(schemaName) > 0 && !strings.EqualFold(schemaName, trigID.SchemaName()) { + continue + } + // The above matches, so this counts as a match + if resolvedID.IsValid() { + trigTableName := TriggerIDToTableName(trigID) + resolvedTableName := TriggerIDToTableName(resolvedID) + return id.NullTrigger, fmt.Errorf("`%s.%s` is ambiguous, matches `%s` and `%s`", + schemaName, formattedName, trigTableName.String(), resolvedTableName.String()) + } + resolvedID = trigID + } + return resolvedID, nil +} + +// iterateIDs iterates over all trigger IDs in the collection. +func (pgt *Collection) iterateIDs(ctx context.Context, callback func(trigID id.Trigger) (stop bool, err error)) error { + for _, trigID := range pgt.idCache { + stop, err := callback(trigID) + if err != nil { + return err + } else if stop { + return nil + } + } + return nil +} + +// IterateTriggers iterates over all triggers in the collection. +func (pgt *Collection) IterateTriggers(ctx context.Context, callback func(t Trigger) (stop bool, err error)) error { + for _, trigID := range pgt.idCache { + stop, err := callback(pgt.accessCache[trigID]) + if err != nil { + return err + } else if stop { + return nil + } + } + return nil +} + +// Clone returns a new *Collection with the same contents as the original. +func (pgt *Collection) Clone(ctx context.Context) *Collection { + return &Collection{ + accessCache: maps.Clone(pgt.accessCache), + tableCache: maps.Clone(pgt.tableCache), + idCache: slices.Clone(pgt.idCache), + underlyingMap: pgt.underlyingMap, + mapHash: pgt.mapHash, + ns: pgt.ns, + } +} + +// Map writes any cached sequences to the underlying map, and then returns the underlying map. +func (pgt *Collection) Map(ctx context.Context) (prolly.AddressMap, error) { + return pgt.underlyingMap, nil +} + +// DiffersFrom returns true when the hash that is associated with the underlying map for this collection is different +// from the hash in the given root. +func (pgt *Collection) DiffersFrom(ctx context.Context, root objinterface.RootValue) bool { + hashOnGivenRoot, err := pgt.LoadCollectionHash(ctx, root) + if err != nil { + return true + } + if pgt.mapHash.Equal(hashOnGivenRoot) { + return false + } + // An empty map should match an uninitialized collection on the root + count, err := pgt.underlyingMap.Count() + if err == nil && count == 0 && hashOnGivenRoot.IsEmpty() { + return false + } + return true +} + +// reloadCaches writes the underlying map's contents to the caches. +func (pgt *Collection) reloadCaches(ctx context.Context) error { + count, err := pgt.underlyingMap.Count() + if err != nil { + return err + } + + clear(pgt.accessCache) + clear(pgt.tableCache) + pgt.mapHash = pgt.underlyingMap.HashOf() + pgt.idCache = make([]id.Trigger, 0, count) + + return pgt.underlyingMap.IterAll(ctx, func(_ string, h hash.Hash) error { + if h.IsEmpty() { + return nil + } + data, err := pgt.ns.ReadBytes(ctx, h) + if err != nil { + return err + } + t, err := DeserializeTrigger(ctx, data) + if err != nil { + return err + } + pgt.accessCache[t.ID] = t + tableID := id.NewTable(t.ID.SchemaName(), t.ID.TableName()) + pgt.tableCache[tableID] = append(pgt.tableCache[tableID], t.ID) + pgt.idCache = append(pgt.idCache, t.ID) + return nil + }) +} + +// tableNameToID returns the ID that was encoded via the Name() call, as the returned TableName contains additional +// information (which this is able to process). +func (pgt *Collection) tableNameToID(schemaName string, formattedName string) id.Trigger { + names := strings.Split(formattedName, ".") + if len(names) != 2 { + return id.NullTrigger + } + return id.NewTrigger(schemaName, names[0], names[1]) +} + +// GetID implements the interface objinterface.RootObject. +func (trigger Trigger) GetID() objinterface.RootObjectID { + return objinterface.RootObjectID_Triggers +} + +// HashOf implements the interface objinterface.RootObject. +func (trigger Trigger) HashOf(ctx context.Context) (hash.Hash, error) { + data, err := trigger.Serialize(ctx) + if err != nil { + return hash.Hash{}, err + } + return hash.Of(data), nil +} + +// Name implements the interface objinterface.RootObject. +func (trigger Trigger) Name() doltdb.TableName { + return TriggerIDToTableName(trigger.ID) +} + +// TriggerIDToTableName returns the ID in a format that's better for user consumption. +func TriggerIDToTableName(trigID id.Trigger) doltdb.TableName { + return doltdb.TableName{ + Name: fmt.Sprintf("%s.%s", trigID.TableName(), trigID.TriggerName()), + Schema: trigID.SchemaName(), + } +} diff --git a/core/triggers/collection_funcs.go b/core/triggers/collection_funcs.go new file mode 100644 index 0000000000..7ac5fa04a7 --- /dev/null +++ b/core/triggers/collection_funcs.go @@ -0,0 +1,109 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package triggers + +import ( + "context" + + "github.com/cockroachdb/errors" + "github.com/dolthub/dolt/go/libraries/doltcore/doltdb" + "github.com/dolthub/dolt/go/libraries/doltcore/merge" + "github.com/dolthub/dolt/go/store/hash" + "github.com/dolthub/dolt/go/store/prolly" + + "github.com/dolthub/doltgresql/core/rootobject/objinterface" + "github.com/dolthub/doltgresql/flatbuffers/gen/serial" +) + +// storage is used to read from and write to the root. +var storage = objinterface.RootObjectSerializer{ + Bytes: (*serial.RootValue).TriggersBytes, + RootValueAdd: serial.RootValueAddTriggers, +} + +// HandleMerge implements the interface objinterface.Collection. +func (*Collection) HandleMerge(ctx context.Context, mro merge.MergeRootObject) (doltdb.RootObject, *merge.MergeStats, error) { + ourTrigger := mro.OurRootObj.(Trigger) + theirTrigger := mro.TheirRootObj.(Trigger) + // Ensure that they have the same identifier + if ourTrigger.ID != theirTrigger.ID { + return nil, nil, errors.Newf("attempted to merge different triggers: `%s` and `%s`", + ourTrigger.Name().String(), theirTrigger.Name().String()) + } + ourHash, err := ourTrigger.HashOf(ctx) + if err != nil { + return nil, nil, err + } + theirHash, err := theirTrigger.HashOf(ctx) + if err != nil { + return nil, nil, err + } + if ourHash.Equal(theirHash) { + return mro.OurRootObj, &merge.MergeStats{ + Operation: merge.TableUnmodified, + Adds: 0, + Deletes: 0, + Modifications: 0, + DataConflicts: 0, + SchemaConflicts: 0, + ConstraintViolations: 0, + }, nil + } + // TODO: figure out a decent merge strategy + return nil, nil, errors.Errorf("unable to merge `%s`", theirTrigger.Name().String()) +} + +// LoadCollection implements the interface objinterface.Collection. +func (*Collection) LoadCollection(ctx context.Context, root objinterface.RootValue) (objinterface.Collection, error) { + return LoadTriggers(ctx, root) +} + +// LoadCollectionHash implements the interface objinterface.Collection. +func (*Collection) LoadCollectionHash(ctx context.Context, root objinterface.RootValue) (hash.Hash, error) { + m, ok, err := storage.GetProllyMap(ctx, root) + if err != nil || !ok { + return hash.Hash{}, err + } + return m.HashOf(), nil +} + +// LoadTriggers loads the triggers collection from the given root. +func LoadTriggers(ctx context.Context, root objinterface.RootValue) (*Collection, error) { + m, ok, err := storage.GetProllyMap(ctx, root) + if err != nil { + return nil, err + } + if !ok { + m, err = prolly.NewEmptyAddressMap(root.NodeStore()) + if err != nil { + return nil, err + } + } + return NewCollection(ctx, m, root.NodeStore()) +} + +// Serializer implements the interface objinterface.Collection. +func (*Collection) Serializer() objinterface.RootObjectSerializer { + return storage +} + +// UpdateRoot implements the interface objinterface.Collection. +func (pgt *Collection) UpdateRoot(ctx context.Context, root objinterface.RootValue) (objinterface.RootValue, error) { + m, err := pgt.Map(ctx) + if err != nil { + return nil, err + } + return storage.WriteProllyMap(ctx, root, m) +} diff --git a/core/triggers/root_object.go b/core/triggers/root_object.go new file mode 100644 index 0000000000..c1c09839ce --- /dev/null +++ b/core/triggers/root_object.go @@ -0,0 +1,118 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package triggers + +import ( + "context" + + "github.com/cockroachdb/errors" + "github.com/dolthub/dolt/go/libraries/doltcore/doltdb" + + "github.com/dolthub/doltgresql/core/id" + "github.com/dolthub/doltgresql/core/rootobject/objinterface" +) + +// DropRootObject implements the interface objinterface.Collection. +func (pgt *Collection) DropRootObject(ctx context.Context, identifier id.Id) error { + if identifier.Section() != id.Section_Trigger { + return errors.Errorf(`trigger %s does not exist`, identifier.String()) + } + return pgt.DropTrigger(ctx, id.Trigger(identifier)) +} + +// GetID implements the interface objinterface.Collection. +func (pgt *Collection) GetID() objinterface.RootObjectID { + return objinterface.RootObjectID_Triggers +} + +// GetRootObject implements the interface objinterface.Collection. +func (pgt *Collection) GetRootObject(ctx context.Context, identifier id.Id) (objinterface.RootObject, bool, error) { + if identifier.Section() != id.Section_Trigger { + return nil, false, nil + } + f, err := pgt.GetTrigger(ctx, id.Trigger(identifier)) + return f, err == nil, err +} + +// HasRootObject implements the interface objinterface.Collection. +func (pgt *Collection) HasRootObject(ctx context.Context, identifier id.Id) (bool, error) { + if identifier.Section() != id.Section_Trigger { + return false, nil + } + return pgt.HasTrigger(ctx, id.Trigger(identifier)), nil +} + +// IDToTableName implements the interface objinterface.Collection. +func (pgt *Collection) IDToTableName(identifier id.Id) doltdb.TableName { + if identifier.Section() != id.Section_Trigger { + return doltdb.TableName{} + } + return TriggerIDToTableName(id.Trigger(identifier)) +} + +// IterAll implements the interface objinterface.Collection. +func (pgt *Collection) IterAll(ctx context.Context, callback func(rootObj objinterface.RootObject) (stop bool, err error)) error { + return pgt.IterateTriggers(ctx, func(t Trigger) (stop bool, err error) { + return callback(t) + }) +} + +// IterIDs implements the interface objinterface.Collection. +func (pgt *Collection) IterIDs(ctx context.Context, callback func(identifier id.Id) (stop bool, err error)) error { + return pgt.iterateIDs(ctx, func(trigID id.Trigger) (stop bool, err error) { + return callback(trigID.AsId()) + }) +} + +// PutRootObject implements the interface objinterface.Collection. +func (pgt *Collection) PutRootObject(ctx context.Context, rootObj objinterface.RootObject) error { + t, ok := rootObj.(Trigger) + if !ok { + return errors.Newf("invalid trigger root object: %T", rootObj) + } + return pgt.AddTrigger(ctx, t) +} + +// RenameRootObject implements the interface objinterface.Collection. +func (pgt *Collection) RenameRootObject(ctx context.Context, oldName id.Id, newName id.Id) error { + if !oldName.IsValid() || !newName.IsValid() || oldName.Section() != newName.Section() || oldName.Section() != id.Section_Trigger { + return errors.New("cannot rename trigger due to invalid name") + } + oldTriggerName := id.Trigger(oldName) + newTriggerName := id.Trigger(newName) + t, err := pgt.GetTrigger(ctx, oldTriggerName) + if err != nil { + return err + } + if err = pgt.DropTrigger(ctx, newTriggerName); err != nil { + return err + } + t.ID = newTriggerName + return pgt.AddTrigger(ctx, t) +} + +// ResolveName implements the interface objinterface.Collection. +func (pgt *Collection) ResolveName(ctx context.Context, name doltdb.TableName) (doltdb.TableName, id.Id, error) { + rawID, err := pgt.resolveName(ctx, name.Schema, name.Name) + if err != nil || !rawID.IsValid() { + return doltdb.TableName{}, id.Null, err + } + return TriggerIDToTableName(rawID), rawID.AsId(), nil +} + +// TableNameToID implements the interface objinterface.Collection. +func (pgt *Collection) TableNameToID(name doltdb.TableName) id.Id { + return pgt.tableNameToID(name.Schema, name.Name).AsId() +} diff --git a/core/triggers/serialization.go b/core/triggers/serialization.go new file mode 100644 index 0000000000..2f5f9e2487 --- /dev/null +++ b/core/triggers/serialization.go @@ -0,0 +1,96 @@ +// Copyright 2024 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package triggers + +import ( + "context" + + "github.com/cockroachdb/errors" + + "github.com/dolthub/doltgresql/core/id" + "github.com/dolthub/doltgresql/utils" +) + +// Serialize returns the Trigger as a byte slice. If the Trigger is invalid, then this returns a nil slice. +func (trigger Trigger) Serialize(ctx context.Context) ([]byte, error) { + if !trigger.ID.IsValid() { + return nil, nil + } + + // Initialize the writer and version + writer := utils.NewWriter(256) + writer.VariableUint(0) // Version + // Write the trigger data + writer.Id(trigger.ID.AsId()) + writer.Id(trigger.Function.AsId()) + writer.Uint8(uint8(trigger.Timing)) + writer.Bool(trigger.ForEachRow) + // TODO: writer.Unknown(trigger.When) + writer.Uint8(uint8(trigger.Deferrable)) + writer.Id(trigger.ReferencedTableName.AsId()) + writer.Bool(trigger.Constraint) + writer.String(trigger.OldTransitionName) + writer.String(trigger.NewTransitionName) + writer.StringSlice(trigger.Arguments) + writer.String(trigger.Definition) + // Write the events + writer.VariableUint(uint64(len(trigger.Events))) + for _, event := range trigger.Events { + writer.Uint8(uint8(event.Type)) + writer.StringSlice(event.ColumnNames) + } + // Returns the data + return writer.Data(), nil +} + +// DeserializeTrigger returns the Trigger that was serialized in the byte slice. Returns an empty Trigger (invalid ID) +// if data is nil or empty. +func DeserializeTrigger(ctx context.Context, data []byte) (Trigger, error) { + if len(data) == 0 { + return Trigger{}, nil + } + reader := utils.NewReader(data) + version := reader.VariableUint() + if version != 0 { + return Trigger{}, errors.Errorf("version %d of triggers is not supported, please upgrade the server", version) + } + + // Read from the reader + t := Trigger{} + t.ID = id.Trigger(reader.Id()) + t.Function = id.Function(reader.Id()) + t.Timing = TriggerTiming(reader.Uint8()) + t.ForEachRow = reader.Bool() + // TODO: trigger.When = reader.Unknown() + t.Deferrable = TriggerDeferrable(reader.Uint8()) + t.ReferencedTableName = id.Table(reader.Id()) + t.Constraint = reader.Bool() + t.OldTransitionName = reader.String() + t.NewTransitionName = reader.String() + t.Arguments = reader.StringSlice() + t.Definition = reader.String() + // Read the events + eventCount := reader.VariableUint() + t.Events = make([]TriggerEvent, eventCount) + for eventIdx := uint64(0); eventIdx < eventCount; eventIdx++ { + t.Events[eventIdx].Type = TriggerEventType(reader.Uint8()) + t.Events[eventIdx].ColumnNames = reader.StringSlice() + } + if !reader.IsEmpty() { + return Trigger{}, errors.Errorf("extra data found while deserializing a trigger") + } + // Return the deserialized object + return t, nil +} diff --git a/flatbuffers/gen/serial/rootvalue.go b/flatbuffers/gen/serial/rootvalue.go index a8a0810ecf..2efd2e366c 100644 --- a/flatbuffers/gen/serial/rootvalue.go +++ b/flatbuffers/gen/serial/rootvalue.go @@ -269,7 +269,41 @@ func (rcv *RootValue) MutateFunctions(j int, n byte) bool { return false } -const RootValueNumFields = 8 +func (rcv *RootValue) Triggers(j int) byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *RootValue) TriggersLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *RootValue) TriggersBytes() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *RootValue) MutateTriggers(j int, n byte) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n) + } + return false +} + +const RootValueNumFields = 9 func RootValueStart(builder *flatbuffers.Builder) { builder.StartObject(RootValueNumFields) @@ -316,6 +350,12 @@ func RootValueAddFunctions(builder *flatbuffers.Builder, functions flatbuffers.U func RootValueStartFunctionsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(1, numElems, 1) } +func RootValueAddTriggers(builder *flatbuffers.Builder, triggers flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(triggers), 0) +} +func RootValueStartTriggersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} func RootValueEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() } diff --git a/flatbuffers/serial/rootvalue.fbs b/flatbuffers/serial/rootvalue.fbs index db6073566a..8b85047268 100644 --- a/flatbuffers/serial/rootvalue.fbs +++ b/flatbuffers/serial/rootvalue.fbs @@ -33,6 +33,8 @@ table RootValue { types:[ubyte]; // Serialized AddressMap. functions:[ubyte]; // Serialized AddressMap. + + triggers:[ubyte]; // Serialized AddressMap. } table DatabaseSchema { diff --git a/postgres/parser/sem/tree/name_part.go b/postgres/parser/sem/tree/name_part.go index dbbbf9594c..63e0b78124 100644 --- a/postgres/parser/sem/tree/name_part.go +++ b/postgres/parser/sem/tree/name_part.go @@ -52,6 +52,11 @@ func (n *Name) Format(ctx *FmtCtx) { } } +// IsEmpty returns whether the name is empty. +func (n *Name) IsEmpty() bool { + return n == nil || len(*n) == 0 +} + // NameStringP escapes an identifier stored in a heap string to a SQL // identifier, avoiding a heap allocation. func NameStringP(s *string) string { diff --git a/server/analyzer/assign_triggers.go b/server/analyzer/assign_triggers.go new file mode 100644 index 0000000000..8b37cd9e1e --- /dev/null +++ b/server/analyzer/assign_triggers.go @@ -0,0 +1,208 @@ +// Copyright 2024 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package analyzer + +import ( + "fmt" + "sort" + + "github.com/dolthub/doltgresql/core" + "github.com/dolthub/doltgresql/core/id" + "github.com/dolthub/doltgresql/core/triggers" + pgexprs "github.com/dolthub/doltgresql/server/expression" + pgnodes "github.com/dolthub/doltgresql/server/node" + pgtransform "github.com/dolthub/doltgresql/server/transform" + + "github.com/dolthub/go-mysql-server/sql" + "github.com/dolthub/go-mysql-server/sql/analyzer" + "github.com/dolthub/go-mysql-server/sql/plan" + "github.com/dolthub/go-mysql-server/sql/transform" +) + +// AssignTriggers assigns triggers wherever they're needed. +func AssignTriggers(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope *plan.Scope, selector analyzer.RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) { + return pgtransform.NodeWithOpaque(node, func(node sql.Node) (sql.Node, transform.TreeIdentity, error) { + switch node := node.(type) { + case *plan.DeleteFrom, *plan.InsertInto, *plan.Truncate, *plan.Update: + sch, beforeTrigs, afterTrigs, err := getTriggerInformation(ctx, node) + if err != nil { + return nil, transform.NewTree, err + } + if len(beforeTrigs) == 0 && len(afterTrigs) == 0 { + return node, transform.SameTree, nil + } + newNode := node + if len(beforeTrigs) > 0 { + handling := getTriggerRowHandling(node) + newNode, err = nodeWithTriggers(ctx, newNode, &pgnodes.TriggerExecution{ + Triggers: beforeTrigs, + Split: handling, + Return: handling, + Sch: sch, + Source: getTriggerSource(node), + Runner: pgexprs.StatementRunner{Runner: a.Runner}, + }) + if err != nil { + return nil, transform.NewTree, err + } + } + if len(afterTrigs) > 0 { + newNode = &pgnodes.TriggerExecution{ + Triggers: afterTrigs, + Split: getTriggerRowHandling(node), + Return: pgnodes.TriggerExecutionRowHandling_None, + Sch: sch, + Source: newNode, + Runner: pgexprs.StatementRunner{Runner: a.Runner}, + } + } + return newNode, transform.NewTree, nil + default: + return node, transform.SameTree, nil + } + }) +} + +// getTriggerInformation loads information that is common for the different trigger types. +func getTriggerInformation(ctx *sql.Context, node sql.Node) (sch sql.Schema, beforeTrigs []triggers.Trigger, afterTrigs []triggers.Trigger, err error) { + var tbl sql.Table + switch node := node.(type) { + case *plan.DeleteFrom: + tbl, err = plan.GetDeletable(node.Child) + if err != nil { + return nil, nil, nil, err + } + case *plan.InsertInto: + tbl, err = plan.GetInsertable(node.Destination) + if err != nil { + return nil, nil, nil, err + } + case *plan.Truncate: + tbl, err = plan.GetTruncatable(node.Child) + if err != nil { + return nil, nil, nil, err + } + case *plan.Update: + tbl, err = plan.GetUpdatable(node.Child) + if err != nil { + return nil, nil, nil, err + } + default: + return nil, nil, nil, nil + } + tblID, ok, _ := id.GetFromTable(ctx, tbl) + if !ok { + return nil, nil, nil, nil + } + trigCollection, err := core.GetTriggersCollectionFromContext(ctx) + if err != nil { + return nil, nil, nil, err + } + allTrigs := trigCollection.GetTriggersForTable(ctx, tblID) + // Return early if there are no triggers for the table + if len(allTrigs) == 0 { + return tbl.Schema(), nil, nil, nil + } + // Trigger order is determined by the name + sort.Slice(allTrigs, func(i, j int) bool { + return allTrigs[i].ID.TriggerName() < allTrigs[j].ID.TriggerName() + }) + beforeTrigs = make([]triggers.Trigger, 0, len(allTrigs)) + afterTrigs = make([]triggers.Trigger, 0, len(allTrigs)) + for _, trig := range allTrigs { + matchesEventType := false + for _, event := range trig.Events { + switch node.(type) { + case *plan.DeleteFrom: + if event.Type == triggers.TriggerEventType_Delete { + matchesEventType = true + } + case *plan.InsertInto: + if event.Type == triggers.TriggerEventType_Insert { + matchesEventType = true + } + case *plan.Truncate: + if event.Type == triggers.TriggerEventType_Truncate { + matchesEventType = true + } + case *plan.Update: + if event.Type == triggers.TriggerEventType_Update { + matchesEventType = true + } + } + } + if !matchesEventType { + continue + } + switch trig.Timing { + case triggers.TriggerTiming_Before: + beforeTrigs = append(beforeTrigs, trig) + case triggers.TriggerTiming_After: + afterTrigs = append(afterTrigs, trig) + default: + return nil, nil, nil, fmt.Errorf("trigger timing has not yet been implemented") + } + } + return tbl.Schema(), beforeTrigs, afterTrigs, nil +} + +// getTriggerSource returns the trigger's source node. +func getTriggerSource(node sql.Node) sql.Node { + switch node := node.(type) { + case *plan.DeleteFrom: + return node.Child + case *plan.InsertInto: + return node.Source + case *plan.Truncate: + return node.Child + case *plan.Update: + return node.Child + default: + return node + } +} + +// getTriggerRowHandling returns the trigger's row handling type (based on how GMS passes rows in the intermediate +// steps). +func getTriggerRowHandling(node sql.Node) pgnodes.TriggerExecutionRowHandling { + switch node.(type) { + case *plan.DeleteFrom: + return pgnodes.TriggerExecutionRowHandling_Old + case *plan.InsertInto: + return pgnodes.TriggerExecutionRowHandling_New + case *plan.Truncate: + return pgnodes.TriggerExecutionRowHandling_None + case *plan.Update: + return pgnodes.TriggerExecutionRowHandling_OldNew + default: + return pgnodes.TriggerExecutionRowHandling_None + } +} + +// nodeWithTriggers calls the appropriate WithX function depending on the node type. +func nodeWithTriggers(ctx *sql.Context, node sql.Node, executionNode *pgnodes.TriggerExecution) (sql.Node, error) { + switch node := node.(type) { + case *plan.DeleteFrom: + return node.WithChildren(executionNode) + case *plan.InsertInto: + return node.WithSource(executionNode), nil + case *plan.Truncate: + return node.WithChildren(executionNode) + case *plan.Update: + return node.WithChildren(executionNode) + default: + return nil, fmt.Errorf("unknown node for triggers") + } +} diff --git a/server/analyzer/init.go b/server/analyzer/init.go index 356daf1b89..2babfa310e 100644 --- a/server/analyzer/init.go +++ b/server/analyzer/init.go @@ -28,6 +28,7 @@ const ( ruleId_AddDomainConstraintsToCasts // addDomainConstraintsToCasts ruleId_ApplyTablesForAnalyzeAllTables // applyTablesForAnalyzeAllTables ruleId_AssignInsertCasts // assignInsertCasts + ruleId_AssignTriggers // assignTriggers ruleId_AssignUpdateCasts // assignUpdateCasts ruleId_ConvertDropPrimaryKeyConstraint // convertDropPrimaryKeyConstraint ruleId_GenerateForeignKeyName // generateForeignKeyName @@ -53,6 +54,7 @@ func Init() { analyzer.Rule{Id: ruleId_ValidateColumnDefaults, Apply: ValidateColumnDefaults}, analyzer.Rule{Id: ruleId_AssignInsertCasts, Apply: AssignInsertCasts}, analyzer.Rule{Id: ruleId_AssignUpdateCasts, Apply: AssignUpdateCasts}, + analyzer.Rule{Id: ruleId_AssignTriggers, Apply: AssignTriggers}, analyzer.Rule{Id: ruleId_ReplaceIndexedTables, Apply: ReplaceIndexedTables}, ) diff --git a/server/ast/create_function.go b/server/ast/create_function.go index af75c73a21..7947f447f2 100644 --- a/server/ast/create_function.go +++ b/server/ast/create_function.go @@ -60,7 +60,12 @@ func nodeCreateFunction(ctx *Context, node *tree.CreateFunction) (vitess.Stateme case *types.T: retType = pgtypes.NewUnresolvedDoltgresType("", strings.ToLower(typ.Name())) default: - retType = pgtypes.NewUnresolvedDoltgresType("", strings.ToLower(typ.SQLString())) + sqlString := strings.ToLower(typ.SQLString()) + if sqlString == "trigger" { + retType = pgtypes.Trigger + } else { + retType = pgtypes.NewUnresolvedDoltgresType("", sqlString) + } } } paramNames := make([]string, len(node.Args)) diff --git a/server/ast/create_trigger.go b/server/ast/create_trigger.go index 5bdc5b2b46..5aefb4af95 100644 --- a/server/ast/create_trigger.go +++ b/server/ast/create_trigger.go @@ -17,10 +17,77 @@ package ast import ( vitess "github.com/dolthub/vitess/go/vt/sqlparser" + "github.com/dolthub/doltgresql/core/id" + "github.com/dolthub/doltgresql/core/triggers" + pgnodes "github.com/dolthub/doltgresql/server/node" + "github.com/dolthub/doltgresql/postgres/parser/sem/tree" ) // nodeCreateTrigger handles *tree.CreateTrigger nodes. func nodeCreateTrigger(ctx *Context, node *tree.CreateTrigger) (vitess.Statement, error) { - return NotYetSupportedError("CREATE TRIGGER statement is not yet supported") + if node.Constraint { + return NotYetSupportedError("CREATE CONSTRAINT TRIGGER is not yet supported") + } + if !node.RefTable.IsEmpty() { + return NotYetSupportedError("FROM is not yet supported for CREATE TRIGGER") + } + if node.Deferrable != tree.TriggerNotDeferrable { + return NotYetSupportedError("DEFERRABLE is not yet supported for CREATE TRIGGER") + } + if len(node.Relations) > 0 { + return NotYetSupportedError("REFERENCING is not yet supported for CREATE TRIGGER") + } + if !node.ForEachRow { + return NotYetSupportedError("FOR EACH STATEMENT is not yet supported for CREATE TRIGGER") + } + funcName := node.FuncName.ToTableName() + var timing triggers.TriggerTiming + switch node.Time { + case tree.TriggerTimeBefore: + timing = triggers.TriggerTiming_Before + case tree.TriggerTimeAfter: + timing = triggers.TriggerTiming_After + case tree.TriggerTimeInsteadOf: + return NotYetSupportedError("INSTEAD OF is not yet supported for CREATE TRIGGER") + } + var events []triggers.TriggerEvent + for _, event := range node.Events { + switch event.Type { + case tree.TriggerEventInsert: + events = append(events, triggers.TriggerEvent{ + Type: triggers.TriggerEventType_Insert, + }) + case tree.TriggerEventUpdate: + if len(event.Cols) > 0 { + return NotYetSupportedError("UPDATE specific columns are not yet supported for CREATE TRIGGER") + } + events = append(events, triggers.TriggerEvent{ + Type: triggers.TriggerEventType_Update, + ColumnNames: event.Cols.ToStrings(), + }) + case tree.TriggerEventDelete: + events = append(events, triggers.TriggerEvent{ + Type: triggers.TriggerEventType_Delete, + }) + case tree.TriggerEventTruncate: + return NotYetSupportedError("TRUNCATE is not yet supported for CREATE TRIGGER") + default: + return NotYetSupportedError("UNKNOWN EVENT TYPE is not yet supported for CREATE TRIGGER") + } + } + return vitess.InjectedStatement{ + Statement: pgnodes.NewCreateTrigger( + id.NewTrigger(node.OnTable.Schema(), node.OnTable.Table(), node.Name.String()), + id.NewFunction(funcName.Schema(), funcName.Table()), + node.Replace, + timing, + events, + node.ForEachRow, + nil, // TODO: node.When (expr) + node.Args.ToStrings(), + ctx.originalQuery, + ), + Children: nil, + }, nil } diff --git a/server/expression/statement_runner.go b/server/expression/statement_runner.go new file mode 100644 index 0000000000..243c188f88 --- /dev/null +++ b/server/expression/statement_runner.go @@ -0,0 +1,74 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package expression + +import ( + "github.com/dolthub/go-mysql-server/sql" + "github.com/dolthub/go-mysql-server/sql/analyzer" + + pgtypes "github.com/dolthub/doltgresql/server/types" +) + +// StatementRunner is an expression that can be added to a node to grab the statement runner. +type StatementRunner struct { + Runner analyzer.StatementRunner +} + +var _ sql.Expression = StatementRunner{} +var _ analyzer.Interpreter = StatementRunner{} + +// Children implements the sql.Expression interface. +func (StatementRunner) Children() []sql.Expression { + return nil +} + +// Eval implements the sql.Expression interface. +func (StatementRunner) Eval(ctx *sql.Context, row sql.Row) (any, error) { + return nil, nil +} + +// IsNullable implements the sql.Expression interface. +func (StatementRunner) IsNullable() bool { + return false +} + +// Resolved implements the sql.Expression interface. +func (StatementRunner) Resolved() bool { + return true +} + +// SetStatementRunner implements the sql.Expression interface. +func (sr StatementRunner) SetStatementRunner(ctx *sql.Context, runner analyzer.StatementRunner) sql.Expression { + sr.Runner = runner + return sr +} + +// String implements the sql.Expression interface. +func (StatementRunner) String() string { + return "StatementRunner" +} + +// Type implements the sql.Expression interface. +func (StatementRunner) Type() sql.Type { + return pgtypes.Unknown +} + +// WithChildren implements the sql.Expression interface. +func (sr StatementRunner) WithChildren(children ...sql.Expression) (sql.Expression, error) { + if len(children) != 0 { + return nil, sql.ErrInvalidChildrenNumber.New(sr, len(children), 0) + } + return sr, nil +} diff --git a/server/functions/framework/interpreted_function.go b/server/functions/framework/interpreted_function.go index 9defc7b86e..1e7848edc3 100644 --- a/server/functions/framework/interpreted_function.go +++ b/server/functions/framework/interpreted_function.go @@ -105,10 +105,10 @@ func (InterpretedFunction) QuerySingleReturn(ctx *sql.Context, stack plpgsql.Int if len(bindings) > 0 { for i, bindingName := range bindings { variable := stack.GetVariable(bindingName) - if variable == nil { + if variable.Type == nil { return nil, fmt.Errorf("variable `%s` could not be found", bindingName) } - formattedVar, err := variable.Type.FormatValue(variable.Value) + formattedVar, err := variable.Type.FormatValue(*variable.Value) if err != nil { return nil, err } @@ -140,6 +140,9 @@ func (InterpretedFunction) QuerySingleReturn(ctx *sql.Context, stack plpgsql.Int if targetType == nil { return rows[0][0], nil } + if rows[0][0] == nil { + return nil, nil + } fromType, ok := sch[0].Type.(*pgtypes.DoltgresType) if !ok { fromType, err = pgtypes.FromGmsTypeToDoltgresType(sch[0].Type) @@ -161,10 +164,10 @@ func (InterpretedFunction) QueryMultiReturn(ctx *sql.Context, stack plpgsql.Inte if len(bindings) > 0 { for i, bindingName := range bindings { variable := stack.GetVariable(bindingName) - if variable == nil { + if variable.Type == nil { return nil, fmt.Errorf("variable `%s` could not be found", bindingName) } - formattedVar, err := variable.Type.FormatValue(variable.Value) + formattedVar, err := variable.Type.FormatValue(*variable.Value) if err != nil { return nil, err } diff --git a/server/node/create_trigger.go b/server/node/create_trigger.go new file mode 100644 index 0000000000..76d3dd0eee --- /dev/null +++ b/server/node/create_trigger.go @@ -0,0 +1,199 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package node + +import ( + "github.com/cockroachdb/errors" + "github.com/dolthub/dolt/go/libraries/doltcore/sqle/resolve" + "github.com/dolthub/go-mysql-server/sql" + "github.com/dolthub/go-mysql-server/sql/plan" + vitess "github.com/dolthub/vitess/go/vt/sqlparser" + + "github.com/dolthub/doltgresql/core/functions" + "github.com/dolthub/doltgresql/core/triggers" + pgtypes "github.com/dolthub/doltgresql/server/types" + + "github.com/dolthub/doltgresql/core" + "github.com/dolthub/doltgresql/core/id" +) + +// CreateTrigger implements CREATE TRIGGER. +type CreateTrigger struct { + Name id.Trigger + Function id.Function + Replace bool + Timing triggers.TriggerTiming + Events []triggers.TriggerEvent + ForEachRow bool + When sql.Expression + Arguments []string + Definition string +} + +var _ sql.ExecSourceRel = (*CreateTrigger)(nil) +var _ vitess.Injectable = (*CreateTrigger)(nil) + +// NewCreateTrigger returns a new *CreateTrigger. +func NewCreateTrigger( + triggerName id.Trigger, + functionName id.Function, + replace bool, + timing triggers.TriggerTiming, + events []triggers.TriggerEvent, + forEachRow bool, + when sql.Expression, + arguments []string, + definition string) *CreateTrigger { + return &CreateTrigger{ + Name: triggerName, + Function: functionName, + Replace: replace, + Timing: timing, + Events: events, + ForEachRow: forEachRow, + When: when, + Arguments: arguments, + Definition: definition, + } +} + +// Children implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) Children() []sql.Node { + return nil +} + +// IsReadOnly implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) IsReadOnly() bool { + return false +} + +// Resolved implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) Resolved() bool { + return true +} + +// RowIter implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) { + schema, err := core.GetSchemaName(ctx, nil, c.Name.SchemaName()) + if err != nil { + return nil, err + } + triggerID := id.NewTrigger(schema, c.Name.TableName(), c.Name.TriggerName()) + relationType, err := core.GetRelationType(ctx, schema, c.Name.TableName()) + if err != nil { + return nil, err + } + if relationType == core.RelationType_DoesNotExist { + return nil, errors.Errorf(`relation "%s" does not exist`, c.Name.TableName()) + } else if relationType != core.RelationType_Table { + return nil, errors.Errorf(`"%s" is not a table or view`, c.Name.TableName()) + } + function, err := loadFunction(ctx, nil, c.Function) + if err != nil { + return nil, err + } + if !function.ID.IsValid() { + return nil, errors.Errorf("function %s() does not exist", c.Function.FunctionName()) + } + if function.ReturnType != pgtypes.Trigger.ID { + return nil, errors.Errorf(`function %s must return type trigger`, function.ID.FunctionName()) + } + trigCollection, err := core.GetTriggersCollectionFromContext(ctx) + if err != nil { + return nil, err + } + if c.Replace && trigCollection.HasTrigger(ctx, triggerID) { + if err = trigCollection.DropTrigger(ctx, triggerID); err != nil { + return nil, err + } + } + err = trigCollection.AddTrigger(ctx, triggers.Trigger{ + ID: triggerID, + Function: function.ID, + Timing: c.Timing, + Events: c.Events, + ForEachRow: c.ForEachRow, + When: nil, + Deferrable: triggers.TriggerDeferrable_NotDeferrable, + ReferencedTableName: "", + Constraint: false, + OldTransitionName: "", + NewTransitionName: "", + Arguments: c.Arguments, + Definition: c.Definition, + }) + if err != nil { + return nil, err + } + return sql.RowsToRowIter(), nil +} + +// Schema implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) Schema() sql.Schema { + return nil +} + +// String implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) String() string { + return "CREATE TRIGGER" +} + +// WithChildren implements the interface sql.ExecSourceRel. +func (c *CreateTrigger) WithChildren(children ...sql.Node) (sql.Node, error) { + return plan.NillaryWithChildren(c, children...) +} + +// WithResolvedChildren implements the interface vitess.Injectable. +func (c *CreateTrigger) WithResolvedChildren(children []any) (any, error) { + if len(children) != 0 { + return nil, ErrVitessChildCount.New(0, len(children)) + } + return c, nil +} + +// loadFunction loads the function with the given ID from the given collection. If the collection is nil, then this also +// loads the collection from the context. +func loadFunction(ctx *sql.Context, funcCollection *functions.Collection, funcID id.Function) (functions.Function, error) { + var err error + if funcCollection == nil { + funcCollection, err = core.GetFunctionsCollectionFromContext(ctx) + if err != nil { + return functions.Function{}, err + } + } + var function functions.Function + if len(funcID.SchemaName()) > 0 { + function, err = funcCollection.GetFunction(ctx, funcID) + if err != nil { + return functions.Function{}, err + } + } else { + searchPaths, err := resolve.SearchPath(ctx) + if err != nil { + return functions.Function{}, err + } + searchPaths = append(searchPaths, "pg_catalog") // This isn't included in the search path but functions use it + for _, searchPath := range searchPaths { + function, err = funcCollection.GetFunction(ctx, id.NewFunction(searchPath, funcID.FunctionName())) + if err != nil { + return functions.Function{}, err + } + if function.ID.IsValid() { + break + } + } + } + return function, nil +} diff --git a/server/node/trigger_execution.go b/server/node/trigger_execution.go new file mode 100644 index 0000000000..a8d9769333 --- /dev/null +++ b/server/node/trigger_execution.go @@ -0,0 +1,231 @@ +// Copyright 2025 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package node + +import ( + "fmt" + + "github.com/cockroachdb/errors" + "github.com/dolthub/go-mysql-server/sql" + "github.com/dolthub/go-mysql-server/sql/analyzer" + "github.com/dolthub/go-mysql-server/sql/rowexec" + + "github.com/dolthub/doltgresql/core/triggers" + pgexprs "github.com/dolthub/doltgresql/server/expression" + "github.com/dolthub/doltgresql/server/functions/framework" + "github.com/dolthub/doltgresql/server/plpgsql" + pgtypes "github.com/dolthub/doltgresql/server/types" +) + +// TriggerExecutionRowHandling states how to interpret the source row, or how to return the resulting row. +type TriggerExecutionRowHandling uint8 + +const ( + TriggerExecutionRowHandling_None TriggerExecutionRowHandling = iota + TriggerExecutionRowHandling_Old + TriggerExecutionRowHandling_OldNew + TriggerExecutionRowHandling_NewOld + TriggerExecutionRowHandling_New +) + +// TriggerExecution handles the execution of a set of triggers on a table. +type TriggerExecution struct { + Triggers []triggers.Trigger + Split TriggerExecutionRowHandling // How the source row should be split + Return TriggerExecutionRowHandling // How the returned rows should be combined + Sch sql.Schema + Source sql.Node + Runner pgexprs.StatementRunner +} + +var _ sql.ExecSourceRel = (*TriggerExecution)(nil) +var _ sql.Expressioner = (*TriggerExecution)(nil) + +func (te *TriggerExecution) Children() []sql.Node { + return []sql.Node{te.Source} +} + +// Expressions implements the interface sql.Expressioner. +func (te *TriggerExecution) Expressions() []sql.Expression { + return []sql.Expression{te.Runner} +} + +// IsReadOnly implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) IsReadOnly() bool { + return te.Source.IsReadOnly() +} + +// Resolved implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) Resolved() bool { + return te.Source.Resolved() +} + +// RowIter implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) RowIter(ctx *sql.Context, r sql.Row) (sql.RowIter, error) { + sourceIter, err := rowexec.DefaultBuilder.Build(ctx, te.Source, r) + if err != nil { + return nil, err + } + // If there are no triggers, then we'll just return the source iter + if len(te.Triggers) == 0 { + return sourceIter, nil + } + trigFuncs := make([]framework.InterpretedFunction, len(te.Triggers)) + for i, trig := range te.Triggers { + trigFuncs[i], err = te.loadTriggerFunction(ctx, trig) + if err != nil { + return nil, err + } + } + return &triggerExecutionIter{ + functions: trigFuncs, + split: te.Split, + treturn: te.Return, + runner: te.Runner.Runner, + sch: te.Sch, + source: sourceIter, + }, nil +} + +// Schema implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) Schema() sql.Schema { + return te.Source.Schema() +} + +// String implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) String() string { + return "TRIGGER EXECUTION" +} + +// WithChildren implements the interface sql.ExecSourceRel. +func (te *TriggerExecution) WithChildren(children ...sql.Node) (sql.Node, error) { + if len(children) != 1 { + return nil, sql.ErrInvalidChildrenNumber.New(te, len(children), 1) + } + newTe := *te + newTe.Source = children[0] + return &newTe, nil +} + +// WithExpressions implements the interface sql.Expressioner. +func (te *TriggerExecution) WithExpressions(expressions ...sql.Expression) (sql.Node, error) { + if len(expressions) != 1 { + return nil, sql.ErrInvalidChildrenNumber.New(te, len(expressions), 1) + } + newTe := *te + newTe.Runner = expressions[0].(pgexprs.StatementRunner) + return &newTe, nil +} + +// loadTriggerFunction loads the given trigger's framework.InterpretedFunction. +func (te *TriggerExecution) loadTriggerFunction(ctx *sql.Context, trigger triggers.Trigger) (framework.InterpretedFunction, error) { + function, err := loadFunction(ctx, nil, trigger.Function) + if err != nil { + return framework.InterpretedFunction{}, err + } + if !function.ID.IsValid() { + return framework.InterpretedFunction{}, errors.Errorf("function %s() does not exist", trigger.Function.FunctionName()) + } + if function.ReturnType != pgtypes.Trigger.ID { + return framework.InterpretedFunction{}, errors.Errorf(`function %s must return type trigger`, function.ID.FunctionName()) + } + return framework.InterpretedFunction{ + ID: function.ID, + ReturnType: pgtypes.Trigger, + ParameterNames: nil, + ParameterTypes: nil, + Variadic: function.Variadic, + IsNonDeterministic: function.IsNonDeterministic, + Strict: function.Strict, + Statements: function.Operations, + }, nil +} + +// triggerExecutionIter is the iterator for TriggerExecution. +type triggerExecutionIter struct { + functions []framework.InterpretedFunction + split TriggerExecutionRowHandling + treturn TriggerExecutionRowHandling + runner analyzer.StatementRunner + sch sql.Schema + source sql.RowIter +} + +var _ sql.RowIter = (*triggerExecutionIter)(nil) + +// Next implements the interface sql.RowIter. +func (t *triggerExecutionIter) Next(ctx *sql.Context) (sql.Row, error) { + nextRow, err := t.source.Next(ctx) + if err != nil { + return nextRow, err + } + var oldRow sql.Row + var newRow sql.Row + switch t.split { + case TriggerExecutionRowHandling_Old: + oldRow = nextRow + case TriggerExecutionRowHandling_OldNew: + oldRow = nextRow[:len(t.sch)] + newRow = nextRow[len(t.sch):] + case TriggerExecutionRowHandling_NewOld: + newRow = nextRow[:len(t.sch)] + oldRow = nextRow[len(t.sch):] + case TriggerExecutionRowHandling_New: + newRow = nextRow + } + for _, function := range t.functions { + returnedValue, err := plpgsql.TriggerCall(ctx, function, t.runner, t.sch, oldRow, newRow) + if err != nil { + return nil, err + } + if returnedValue == nil { + return make(sql.Row, len(nextRow)), nil + } + var ok bool + returnedRow, ok := returnedValue.(sql.Row) + if !ok { + return nil, fmt.Errorf("invalid trigger return value") + } + switch t.split { + case TriggerExecutionRowHandling_Old: + oldRow = returnedRow + case TriggerExecutionRowHandling_OldNew, TriggerExecutionRowHandling_NewOld, TriggerExecutionRowHandling_New: + newRow = returnedRow + } + } + switch t.treturn { + case TriggerExecutionRowHandling_Old: + return oldRow, nil + case TriggerExecutionRowHandling_OldNew: + retRow := make(sql.Row, len(nextRow)) + copy(retRow, oldRow) + copy(retRow[len(oldRow):], newRow) + return retRow, nil + case TriggerExecutionRowHandling_NewOld: + retRow := make(sql.Row, len(nextRow)) + copy(retRow, newRow) + copy(retRow[len(newRow):], oldRow) + return retRow, nil + case TriggerExecutionRowHandling_New: + return newRow, nil + default: + return nextRow, nil + } +} + +// Close implements the interface sql.RowIter. +func (t *triggerExecutionIter) Close(ctx *sql.Context) error { + return t.source.Close(ctx) +} diff --git a/server/plpgsql/interpreter_logic.go b/server/plpgsql/interpreter_logic.go index 634e799777..68b0e8a14e 100644 --- a/server/plpgsql/interpreter_logic.go +++ b/server/plpgsql/interpreter_logic.go @@ -48,7 +48,6 @@ var GetTypesCollectionFromContext func(ctx *sql.Context) (*typecollection.TypeCo // Call runs the contained operations on the given runner. func Call(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.StatementRunner, paramsAndReturn []*pgtypes.DoltgresType, vals []any) (any, error) { // Set up the initial state of the function - counter := -1 // We increment before accessing, so start at -1 stack := NewInterpreterStack(runner) // Add the parameters parameterTypes := iFunc.GetParameters() @@ -59,6 +58,24 @@ func Call(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.Statement for i := range vals { stack.NewVariableWithValue(parameterNames[i], parameterTypes[i], vals[i]) } + return call(ctx, iFunc, stack) +} + +// TriggerCall runs the contained trigger operations on the given runner. +func TriggerCall(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.StatementRunner, sch sql.Schema, oldRow sql.Row, newRow sql.Row) (any, error) { + // Set up the initial state of the function + stack := NewInterpreterStack(runner) + // Add the special variables + // TODO: there are way more than just NEW and OLD -> https://www.postgresql.org/docs/15/plpgsql-trigger.html + stack.NewRecord("OLD", sch, oldRow) + stack.NewRecord("NEW", sch, newRow) + return call(ctx, iFunc, stack) +} + +// call runs the contained operations on the given runner. +func call(ctx *sql.Context, iFunc InterpretedFunction, stack InterpreterStack) (any, error) { + // We increment before accessing, so start at -1 + counter := -1 // Run the statements statements := iFunc.GetStatements() for { @@ -73,13 +90,13 @@ func Call(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.Statement switch operation.OpCode { case OpCode_Alias: iv := stack.GetVariable(operation.PrimaryData) - if iv == nil { + if iv.Type == nil { return nil, fmt.Errorf("variable `%s` could not be found", operation.PrimaryData) } - stack.NewVariableAlias(operation.Target, iv) + stack.NewVariableAlias(operation.Target, operation.PrimaryData) case OpCode_Assign: iv := stack.GetVariable(operation.Target) - if iv == nil { + if iv.Type == nil { return nil, fmt.Errorf("variable `%s` could not be found", operation.Target) } retVal, err := iFunc.QuerySingleReturn(ctx, stack, operation.PrimaryData, iv.Type, operation.SecondaryData) @@ -129,7 +146,7 @@ func Call(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.Statement case OpCode_Execute: if len(operation.Target) > 0 { target := stack.GetVariable(operation.Target) - if target == nil { + if target.Type == nil { return nil, fmt.Errorf("variable `%s` could not be found", operation.Target) } retVal, err := iFunc.QuerySingleReturn(ctx, stack, operation.PrimaryData, target.Type, operation.SecondaryData) @@ -212,6 +229,17 @@ func Call(ctx *sql.Context, iFunc InterpretedFunction, runner analyzer.Statement if len(operation.PrimaryData) == 0 { return nil, nil } + // TODO: handle record types properly, we'll special case triggers for now + if iFunc.GetReturn().ID == pgtypes.Trigger.ID && len(operation.SecondaryData) == 1 { + normalized := strings.ReplaceAll(strings.ToLower(operation.PrimaryData), " ", "") + if normalized == "select$1;" { + if strings.EqualFold(operation.SecondaryData[0], "new") { + return *stack.GetVariable("NEW").Value, nil + } else if strings.EqualFold(operation.SecondaryData[0], "old") { + return *stack.GetVariable("OLD").Value, nil + } + } + } return iFunc.QuerySingleReturn(ctx, stack, operation.PrimaryData, iFunc.GetReturn(), operation.SecondaryData) case OpCode_ScopeBegin: stack.PushScope() diff --git a/server/plpgsql/interpreter_stack.go b/server/plpgsql/interpreter_stack.go index 754827de01..1993a5cb9a 100644 --- a/server/plpgsql/interpreter_stack.go +++ b/server/plpgsql/interpreter_stack.go @@ -16,6 +16,7 @@ package plpgsql import ( "fmt" + "strings" "github.com/dolthub/go-mysql-server/sql" "github.com/dolthub/go-mysql-server/sql/analyzer" @@ -24,15 +25,27 @@ import ( "github.com/dolthub/doltgresql/utils" ) -// InterpreterVariable is a variable that lives on the stack. -type InterpreterVariable struct { +// interpreterVariable is a variable that lives on the stack. This will hold an actual value, but will not be directly +// interacted with. InterpreterVariableReference are, instead, the avenue of interaction as a variable may be an +// aggregate type (such as a record). +type interpreterVariable struct { + Record sql.Schema + Type *pgtypes.DoltgresType + Value any +} + +// InterpreterVariableReference is a reference to a variable that lives on the stack. If the type is not null, then it +// is valid to dereference the value for assignment. We make use of references rather than directly interacting with +// the variables as this allows for interacting with sections of aggregate types (such as record) as well as normal +// variable interaction. +type InterpreterVariableReference struct { Type *pgtypes.DoltgresType - Value any + Value *any } // InterpreterScopeDetails contains all of the details that are relevant to a particular scope. type InterpreterScopeDetails struct { - variables map[string]*InterpreterVariable + variables map[string]*interpreterVariable label string } @@ -50,7 +63,7 @@ func NewInterpreterStack(runner analyzer.StatementRunner) InterpreterStack { stack := utils.NewStack[*InterpreterScopeDetails]() // This first push represents the function base, including parameters stack.Push(&InterpreterScopeDetails{ - variables: make(map[string]*InterpreterVariable), + variables: make(map[string]*interpreterVariable), }) return InterpreterStack{ stack: stack, @@ -82,26 +95,74 @@ func (is *InterpreterStack) GetCurrentLabel() string { // GetVariable traverses the stack (starting from the top) to find a variable with a matching name. Returns nil if no // variable was found. -func (is *InterpreterStack) GetVariable(name string) *InterpreterVariable { +func (is *InterpreterStack) GetVariable(name string) InterpreterVariableReference { + // TODO: handle nested record access + fieldName := "" + if strings.Count(name, ".") == 1 { + splitName := strings.Split(name, ".") + name = splitName[0] + fieldName = splitName[1] + } for i := 0; i < is.stack.Len(); i++ { if iv, ok := is.stack.PeekDepth(i).variables[name]; ok { - return iv + if len(fieldName) == 0 { + return InterpreterVariableReference{ + Type: iv.Type, + Value: &iv.Value, + } + } else if len(iv.Record) > 0 { + fieldIdx := iv.Record.IndexOf(fieldName, iv.Record[0].Source) + if fieldIdx == -1 { + // TODO: implement this as a proper error for missing record field rather than the generic "variable not found" + return InterpreterVariableReference{} + } + return InterpreterVariableReference{ + Type: iv.Record[fieldIdx].Type.(*pgtypes.DoltgresType), + Value: &(iv.Value.(sql.Row)[fieldIdx]), + } + } else { + // Can't access fields on an empty record + return InterpreterVariableReference{} + } } } - return nil + return InterpreterVariableReference{} } -// ListVariables returns a map with the names of all variables. -func (is *InterpreterStack) ListVariables() map[string]struct{} { - seen := make(map[string]struct{}) +// ListVariables returns a map with the names of all variables. The attached slice represents field names for records. +// All names are lowercased. +func (is *InterpreterStack) ListVariables() map[string][]string { + seen := make(map[string][]string) for i := 0; i < is.stack.Len(); i++ { - for varName := range is.stack.PeekDepth(i).variables { - seen[varName] = struct{}{} + for varName, iv := range is.stack.PeekDepth(i).variables { + var fieldNames []string + if len(iv.Record) > 0 { + for _, col := range iv.Record { + fieldNames = append(fieldNames, strings.ToLower(col.Name)) + } + } + seen[strings.ToLower(varName)] = fieldNames } } return seen } +// NewRecord creates a new record in the current scope. If a record with the same name exists in a previous scope, then +// that record will be shadowed until the current scope exits. +func (is *InterpreterStack) NewRecord(name string, sch sql.Schema, val sql.Row) { + // TODO: this is currently implemented only for the specific record types used in triggers: OLD and NEW + var newVal sql.Row + if val != nil { + newVal = make(sql.Row, len(val)) + copy(newVal, val) + } + is.stack.Peek().variables[name] = &interpreterVariable{ + Record: sch, + Type: pgtypes.Trigger, // TODO: we need to implement the RECORD pseudotype and replace the TRIGGER type here + Value: newVal, + } +} + // NewVariable creates a new variable in the current scope. If a variable with the same name exists in a previous scope, // then that variable will be shadowed until the current scope exits. func (is *InterpreterStack) NewVariable(name string, typ *pgtypes.DoltgresType) { @@ -110,7 +171,7 @@ func (is *InterpreterStack) NewVariable(name string, typ *pgtypes.DoltgresType) // NewVariableWithValue creates a new variable in the current scope, setting its initial value to the one given. func (is *InterpreterStack) NewVariableWithValue(name string, typ *pgtypes.DoltgresType, val any) { - is.stack.Peek().variables[name] = &InterpreterVariable{ + is.stack.Peek().variables[name] = &interpreterVariable{ Type: typ, Value: val, } @@ -118,14 +179,20 @@ func (is *InterpreterStack) NewVariableWithValue(name string, typ *pgtypes.Doltg // NewVariableAlias creates a new variable alias, named |alias|, in the current frame of this stack, // pointing to the specified |variable|. -func (is *InterpreterStack) NewVariableAlias(alias string, variable *InterpreterVariable) { - is.stack.Peek().variables[alias] = variable +func (is *InterpreterStack) NewVariableAlias(alias string, target string) { + for i := 0; i < is.stack.Len(); i++ { + if iv, ok := is.stack.PeekDepth(i).variables[target]; ok { + // TODO: this won't work for RECORD types + is.stack.Peek().variables[alias] = iv + break + } + } } // PushScope creates a new scope. func (is *InterpreterStack) PushScope() { is.stack.Push(&InterpreterScopeDetails{ - variables: make(map[string]*InterpreterVariable), + variables: make(map[string]*interpreterVariable), }) } @@ -139,10 +206,10 @@ func (is *InterpreterStack) PopScope() { // variable cannot be found. func (is *InterpreterStack) SetVariable(ctx *sql.Context, name string, val any) error { iv := is.GetVariable(name) - if iv == nil { + if iv.Type == nil { return fmt.Errorf("variable `%s` could not be found", name) } - iv.Value = val + *iv.Value = val return nil } diff --git a/server/plpgsql/json.go b/server/plpgsql/json.go index 855cb280bc..0163d55a9e 100644 --- a/server/plpgsql/json.go +++ b/server/plpgsql/json.go @@ -39,8 +39,10 @@ type datatype struct { // datum exists to match the expected JSON format. type datum struct { - Row *plpgSQL_row `json:"PLpgSQL_row"` - Variable *plpgSQL_var `json:"PLpgSQL_var"` + Record *plpgSQL_rec `json:"PLpgSQL_rec"` + RecordField *plpgSQL_recfield `json:"PLpgSQL_recfield"` + Row *plpgSQL_row `json:"PLpgSQL_row"` + Variable *plpgSQL_var `json:"PLpgSQL_var"` } // elsif exists to match the expected JSON format. @@ -66,8 +68,10 @@ type function struct { // plpgSQL_block exists to match the expected JSON format. type plpgSQL_block struct { - Datums []datum `json:"datums"` - Action action `json:"action"` + NewVariableNumber int32 `json:"new_varno"` + OldVariableNumber int32 `json:"old_varno"` + Datums []datum `json:"datums"` + Action action `json:"action"` } // plpgSQL_expr exists to match the expected JSON format. @@ -83,6 +87,18 @@ type plpgSQL_if_elsif struct { LineNumber int32 `json:"lineno"` } +// plpgSQL_rec exists to match the expected JSON format. +type plpgSQL_rec struct { + RefName string `json:"refname"` + DatumNumber int32 `json:"dno"` +} + +// plpgSQL_recfield exists to match the expected JSON format. +type plpgSQL_recfield struct { + FieldName string `json:"fieldname"` + RecordParentNumber int32 `json:"recparentno"` +} + // plpgSQL_row exists to match the expected JSON format. type plpgSQL_row struct { RefName string `json:"refname"` diff --git a/server/plpgsql/json_convert.go b/server/plpgsql/json_convert.go index 8ce865815c..e63670fe42 100644 --- a/server/plpgsql/json_convert.go +++ b/server/plpgsql/json_convert.go @@ -22,15 +22,33 @@ import ( // jsonConvert handles the conversion from the JSON format into a format that is easier to work with. func jsonConvert(jsonBlock plpgSQL_block) (Block, error) { - block := Block{Label: jsonBlock.Action.StmtBlock.Label} + block := Block{ + TriggerNew: jsonBlock.NewVariableNumber, + TriggerOld: jsonBlock.OldVariableNumber, + Label: jsonBlock.Action.StmtBlock.Label, + } for _, v := range jsonBlock.Datums { switch { + case v.Record != nil: + // TODO: support normal record types + if int(v.Record.DatumNumber) > len(block.Records) { + oldRecords := block.Records + block.Records = make([]Record, v.Record.DatumNumber) + copy(block.Records, oldRecords) + } + block.Records[v.Record.DatumNumber-1].Name = v.Record.RefName + case v.RecordField != nil: + if int(v.RecordField.RecordParentNumber) > len(block.Records) { + return Block{}, errors.New("invalid record parent number") + } + block.Records[v.RecordField.RecordParentNumber-1].Fields = append( + block.Records[v.RecordField.RecordParentNumber-1].Fields, v.RecordField.FieldName) case v.Row != nil: if len(v.Row.Fields) != 1 { return Block{}, errors.New("record types are not yet supported") } case v.Variable != nil: - block.Variable = append(block.Variable, Variable{ + block.Variables = append(block.Variables, Variable{ Name: v.Variable.RefName, Type: strings.ToLower(v.Variable.Type.Type.Name), IsParameter: v.Variable.LineNumber == 0, diff --git a/server/plpgsql/parse.go b/server/plpgsql/parse.go index e4addc7728..8805bc02e3 100644 --- a/server/plpgsql/parse.go +++ b/server/plpgsql/parse.go @@ -40,7 +40,7 @@ func Parse(fullCreateFunctionString string) ([]InterpreterOperation, error) { if err != nil { return nil, err } - ops := make([]InterpreterOperation, 0, len(block.Body)+len(block.Variable)) + ops := make([]InterpreterOperation, 0, len(block.Body)+len(block.Variables)) stack := NewInterpreterStack(nil) if err = block.AppendOperations(&ops, &stack); err != nil { return nil, err diff --git a/server/plpgsql/statements.go b/server/plpgsql/statements.go index d1dfb1063d..2a350eb6d2 100644 --- a/server/plpgsql/statements.go +++ b/server/plpgsql/statements.go @@ -16,6 +16,9 @@ package plpgsql import ( "fmt" + "strings" + + "github.com/dolthub/go-mysql-server/sql" "github.com/cockroachdb/errors" pg_query "github.com/pganalyze/pg_query_go/v6" @@ -62,10 +65,13 @@ func (stmt Assignment) AppendOperations(ops *[]InterpreterOperation, stack *Inte // Block contains a collection of statements, alongside the variables that were declared for the block. Only the // top-level block will contain parameter variables. type Block struct { - Variable []Variable - Body []Statement - Label string - IsLoop bool + TriggerNew int32 // When non-zero, indicates that the NEW record exists for use with triggers + TriggerOld int32 // When non-zero, indicates that the OLD record exists for use with triggers + Variables []Variable + Records []Record + Body []Statement + Label string + IsLoop bool } var _ Statement = Block{} @@ -73,7 +79,7 @@ var _ Statement = Block{} // OperationSize implements the interface Statement. func (stmt Block) OperationSize() int32 { total := int32(2) // We start with 2 since we'll have ScopeBegin and ScopeEnd - for _, variable := range stmt.Variable { + for _, variable := range stmt.Variables { if !variable.IsParameter { total++ } @@ -102,7 +108,7 @@ func (stmt Block) AppendOperations(ops *[]InterpreterOperation, stack *Interpret PrimaryData: stmt.Label, Target: loop, }) - for _, variable := range stmt.Variable { + for _, variable := range stmt.Variables { if !variable.IsParameter { *ops = append(*ops, InterpreterOperation{ OpCode: OpCode_Declare, @@ -112,6 +118,13 @@ func (stmt Block) AppendOperations(ops *[]InterpreterOperation, stack *Interpret } stack.NewVariableWithValue(variable.Name, nil, nil) } + for _, record := range stmt.Records { + var fakeSch sql.Schema + for _, fieldName := range record.Fields { + fakeSch = append(fakeSch, &sql.Column{Name: fieldName}) + } + stack.NewRecord(record.Name, fakeSch, nil) + } for _, innerStmt := range stmt.Body { if err := innerStmt.AppendOperations(ops, stack); err != nil { return err @@ -279,6 +292,12 @@ func (r Raise) AppendOperations(ops *[]InterpreterOperation, _ *InterpreterStack return nil } +// Record represents a record (along with known fields for future access). These are exclusively found within Block. +type Record struct { + Name string + Fields []string +} + // Return represents a RETURN statement. type Return struct { Expression string @@ -334,11 +353,31 @@ func substituteVariableReferences(expression string, stack *InterpreterStack) (n } varMap := stack.ListVariables() - for _, token := range scanResult.Tokens { + for i := 0; i < len(scanResult.Tokens); i++ { + token := scanResult.Tokens[i] substring := expression[token.Start:token.End] - if _, ok := varMap[substring]; ok { - referencedVars = append(referencedVars, substring) - newExpression += fmt.Sprintf("$%d ", len(referencedVars)) + // varMap lowercases everything, so we'll lowercase our substring to enable case-insensitivity + if fieldNames, ok := varMap[strings.ToLower(substring)]; ok { + // If there's a '.', then we'll check if this is accessing a record's field (`NEW.val1` for example) + if len(fieldNames) > 0 && i+2 < len(scanResult.Tokens) && scanResult.Tokens[i+1].Token == '.' { + possibleFieldSubstring := expression[scanResult.Tokens[i+2].Start:scanResult.Tokens[i+2].End] + for _, fieldName := range fieldNames { + if fieldName == strings.ToLower(possibleFieldSubstring) { + substring += "." + fieldName + i += 2 + break + } + } + } + // Variables cannot have a '(' after their name as that would classify them as functions, so we have to + // explicitly check for that. This is because variables and functions can share names, for example: + // SELECT COUNT(*) INTO count FROM table_name; + if i+1 >= len(scanResult.Tokens) || scanResult.Tokens[i+1].Token != '(' { + referencedVars = append(referencedVars, substring) + newExpression += fmt.Sprintf("$%d ", len(referencedVars)) + } else { + newExpression += substring + " " + } } else { newExpression += substring + " " } diff --git a/server/transform/node.go b/server/transform/node.go index ad2c11686c..cb3abbd97a 100644 --- a/server/transform/node.go +++ b/server/transform/node.go @@ -54,12 +54,21 @@ func InspectNodeExprs(node sql.Node, exprFunc func(expr sql.Expression) bool) bo // NodeWithOpaque functions similarly to GMS' NodeWithOpaque function, except it also walks through disjointed nodes. func NodeWithOpaque(node sql.Node, nodeFunc gmstransform.NodeFunc) (sql.Node, gmstransform.TreeIdentity, error) { return gmstransform.NodeWithOpaque(node, func(node sql.Node) (sql.Node, gmstransform.TreeIdentity, error) { + treeIdentity := gmstransform.SameTree if disjointedNode, ok := node.(plan.DisjointedChildrenNode); ok { - return handleDisjointedNodes(disjointedNode, func(node sql.Node) (sql.Node, gmstransform.TreeIdentity, error) { + var err error + node, treeIdentity, err = handleDisjointedNodes(disjointedNode, func(node sql.Node) (sql.Node, gmstransform.TreeIdentity, error) { return NodeWithOpaque(node, nodeFunc) }) + if err != nil { + return nil, gmstransform.NewTree, err + } + } + node, newTreeIdentity, err := nodeFunc(node) + if err != nil { + return nil, gmstransform.NewTree, err } - return nodeFunc(node) + return node, treeIdentity && newTreeIdentity, nil }) } diff --git a/server/types/globals.go b/server/types/globals.go index 0c5c1c5f2b..aad8d8f0f6 100644 --- a/server/types/globals.go +++ b/server/types/globals.go @@ -262,7 +262,7 @@ var IDToBuiltInDoltgresType = map[id.Type]*DoltgresType{ toInternal("timestamptz"): TimestampTZ, toInternal("timetz"): TimeTZ, toInternal("tinterval"): Unknown, - toInternal("trigger"): Unknown, + toInternal("trigger"): Trigger, toInternal("tsm_handler"): Unknown, toInternal("tsquery"): Unknown, toInternal("tsrange"): Unknown, diff --git a/server/types/trigger.go b/server/types/trigger.go new file mode 100644 index 0000000000..27f1d7715b --- /dev/null +++ b/server/types/trigger.go @@ -0,0 +1,55 @@ +// Copyright 2024 Dolthub, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package types + +import ( + "github.com/dolthub/doltgresql/core/id" +) + +// Trigger is a pseudo-type that is solely used as a return type for TRIGGER functions. +var Trigger = &DoltgresType{ + ID: toInternal("trigger"), + TypLength: 4, + PassedByVal: false, + TypType: TypeType_Pseudo, + TypCategory: TypeCategory_PseudoTypes, + IsPreferred: false, + IsDefined: true, + Delimiter: ",", + RelID: id.Null, + SubscriptFunc: toFuncID("-"), + Elem: id.NullType, + Array: id.NullType, + InputFunc: toFuncID("_"), + OutputFunc: toFuncID("_"), + ReceiveFunc: toFuncID("-"), + SendFunc: toFuncID("-"), + ModInFunc: toFuncID("-"), + ModOutFunc: toFuncID("-"), + AnalyzeFunc: toFuncID("-"), + Align: TypeAlignment_Char, + Storage: TypeStorage_Plain, + NotNull: false, + BaseTypeID: id.NullType, + TypMod: -1, + NDims: 0, + TypCollation: id.NullCollation, + DefaulBin: "", + Default: "", + Acl: nil, + Checks: nil, + attTypMod: -1, + CompareFunc: toFuncID("-"), +} diff --git a/testing/generation/command_docs/output/create_trigger_test.go b/testing/generation/command_docs/output/create_trigger_test.go index 484c51ad19..03eeb95c60 100644 --- a/testing/generation/command_docs/output/create_trigger_test.go +++ b/testing/generation/command_docs/output/create_trigger_test.go @@ -1,4 +1,4 @@ -// Copyright 2024 Dolthub, Inc. +// Copyright 2025 Dolthub, Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -18,10006 +18,10006 @@ import "testing" func TestCreateTrigger(t *testing.T) { tests := []QueryParses{ - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name NOT DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR INSERT ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER INSERT OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE CONSTRAINT TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE CONSTRAINT TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE CONSTRAINT TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FROM referenced_table_name DEFERRABLE INITIALLY DEFERRED FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name BEFORE DELETE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name BEFORE UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name BEFORE INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name BEFORE DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Converts("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH ROW WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name OLD TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING OLD TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR INSERT ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER DELETE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name AFTER TRUNCATE OR UPDATE OF column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OR UPDATE OF column_name , column_name ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name AFTER INSERT OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER UPDATE OF column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER DELETE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER TRUNCATE OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name AFTER UPDATE OF column_name OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name AFTER TRUNCATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OF column_name , column_name OR DELETE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER INSERT OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name AFTER UPDATE OR TRUNCATE ON table_name REFERENCING NEW TABLE AS transition_relation_name NEW TABLE AS transition_relation_name FOR EACH STATEMENT WHEN ( condition ) EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name FOR ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE FUNCTION function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF INSERT OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR EACH ROW EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR INSERT ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR TRUNCATE ON table_name FOR STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR INSERT ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR UPDATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF INSERT OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR UPDATE OF column_name , column_name ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF INSERT OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF DELETE OR DELETE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE TRIGGER name INSTEAD OF UPDATE OF column_name OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF UPDATE OF column_name , column_name OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), + Parses("CREATE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), Parses("CREATE OR REPLACE TRIGGER name INSTEAD OF DELETE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), - Parses("CREATE TRIGGER name INSTEAD OF TRUNCATE OR TRUNCATE ON table_name FOR EACH STATEMENT EXECUTE PROCEDURE function_name ( arguments )"), } RunTests(t, tests) } diff --git a/testing/go/create_function_test.go b/testing/go/create_function_test.go index 819ef153be..4af0dd9284 100644 --- a/testing/go/create_function_test.go +++ b/testing/go/create_function_test.go @@ -813,14 +813,13 @@ $$ LANGUAGE plpgsql;`, SetUpScript: []string{ "CREATE TABLE test (v1 TEXT);", `CREATE FUNCTION insertion_text() RETURNS TEXT AS $$ - DECLARE - var1 TEXT; - BEGIN - var1 := 'example'; - RETURN var1; - END; - $$ LANGUAGE plpgsql; - `, +DECLARE + var1 TEXT; +BEGIN + var1 := 'example'; + RETURN var1; +END; +$$ LANGUAGE plpgsql;`, }, Assertions: []ScriptTestAssertion{ { diff --git a/testing/go/trigger_test.go b/testing/go/trigger_test.go index 8efd8faaf0..7556efb9b0 100755 --- a/testing/go/trigger_test.go +++ b/testing/go/trigger_test.go @@ -14,20 +14,535 @@ package _go -import "testing" +import ( + "testing" + + "github.com/dolthub/go-mysql-server/sql" +) func TestCreateTrigger(t *testing.T) { RunScripts(t, []ScriptTest{ { - Name: "create trigger with execute call no arguments", + Name: "BEFORE INSERT", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + RETURN NEW; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi_1"}, + {2, "there_2"}, + }, + }, + }, + }, + { + Name: "BEFORE UPDATE", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + RETURN NEW; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE UPDATE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "UPDATE test SET v1 = v1 || '|' WHERE pk IN (1, 2);", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi|_1"}, + {2, "there|_2"}, + }, + }, + }, + }, + { + Name: "BEFORE DELETE", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + INSERT INTO test2 VALUES (OLD.pk, OLD.v1); + RETURN OLD; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE DELETE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + { + Query: "DELETE FROM test WHERE pk = 1;", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi"}, + }, + }, + }, + }, + { + Name: "BEFORE INSERT returning NULL", + Skip: true, // TODO: returning a NULL-filled row isn't quite valid for this + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + INSERT INTO test2 VALUES (NEW.pk, NEW.v1); + RETURN NULL; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi_1"}, + {2, "there_2"}, + }, + }, + }, + }, + { + Name: "BEFORE UPDATE returning NULL", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + INSERT INTO test2 VALUES (NEW.pk, NEW.v1); + RETURN NULL; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE UPDATE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "UPDATE test SET v1 = v1 || '|' WHERE pk IN (1, 2);", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi|_1"}, + {2, "there|_2"}, + }, + }, + }, + }, + { + Name: "BEFORE DELETE returning NULL", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + INSERT INTO test2 VALUES (OLD.pk, OLD.v1); + RETURN NULL; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE DELETE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + { + Query: "DELETE FROM test WHERE pk = 1;", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi"}, + }, + }, + }, + }, + { + Name: "BEFORE UPDATE with DELETE DML", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + INSERT INTO test2 VALUES (OLD.pk, OLD.v1); + RETURN OLD; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE UPDATE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + { + Query: "DELETE FROM test WHERE pk = 1;", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + }, + }, + { + Name: "AFTER INSERT", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + INSERT INTO test2 VALUES (NEW.pk, NEW.v1); + RETURN NEW; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger AFTER INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi_1"}, + {2, "there_2"}, + }, + }, + }, + }, + { + Name: "AFTER UPDATE", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + NEW.v1 := NEW.v1 || '_' || NEW.pk::text; + INSERT INTO test2 VALUES (NEW.pk, NEW.v1); + RETURN NEW; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger AFTER UPDATE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "UPDATE test SET v1 = v1 || '|' WHERE pk IN (1, 2);", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi|"}, + {2, "there|"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi|_1"}, + {2, "there|_2"}, + }, + }, + }, + }, + { + Name: "AFTER DELETE returning NULL", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ + BEGIN + INSERT INTO test2 VALUES (OLD.pk, OLD.v1); + RETURN NULL; + END; + $$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger AFTER DELETE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + { + Query: "DELETE FROM test WHERE pk = 1;", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {1, "hi"}, + }, + }, + }, + }, + { + Name: "Cascading DELETE into INSERT, different tables", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ +BEGIN + INSERT INTO test2 VALUES (OLD.pk, OLD.v1); + RETURN OLD; +END; +$$ LANGUAGE plpgsql;`, + `CREATE FUNCTION trigger_func2() RETURNS TRIGGER AS $$ +BEGIN + NEW.pk := NEW.pk + 100; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE DELETE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test2 FOR EACH ROW EXECUTE FUNCTION trigger_func2();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {1, "hi"}, + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{}, + }, + { + Query: "DELETE FROM test WHERE pk = 1;", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test;", + Expected: []sql.Row{ + {2, "there"}, + }, + }, + { + Query: "SELECT * FROM test2;", + Expected: []sql.Row{ + {101, "hi"}, + }, + }, + }, + }, + { + Name: "Cascading INSERT into UPDATE, same table", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ +BEGIN + UPDATE test SET v1 = v1 || NEW.pk::text; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE FUNCTION trigger_func2() RETURNS TRIGGER AS $$ +BEGIN + NEW.v1 := NEW.v1 || '_u'; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + `CREATE TRIGGER test_trigger2 BEFORE UPDATE ON test FOR EACH ROW EXECUTE FUNCTION trigger_func2();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test ORDER BY pk;", + Skip: true, // TODO: the UPDATE cannot see the table's contents until the INSERT has completely finished + Expected: []sql.Row{ + {1, "hi2_u"}, + {2, "there"}, + }, + }, + }, + }, + { + Name: "Multiple triggers on same table", + SetUpScript: []string{ + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func_a() RETURNS TRIGGER AS $$ +BEGIN + NEW.v1 := NEW.v1 || 'a'; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE FUNCTION trigger_func_c() RETURNS TRIGGER AS $$ +BEGIN + NEW.v1 := NEW.v1 || 'c'; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE FUNCTION trigger_func_b() RETURNS TRIGGER AS $$ +BEGIN + NEW.v1 := NEW.v1 || 'b'; + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger_b BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func_b();`, + `CREATE TRIGGER test_trigger_a BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func_a();`, + `CREATE TRIGGER test_trigger_c BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func_c();`, + }, + Assertions: []ScriptTestAssertion{ + { + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Expected: []sql.Row{}, + }, + { + Query: "SELECT * FROM test ORDER BY pk;", + Expected: []sql.Row{ + {1, "hiabc"}, + {2, "thereabc"}, + }, + }, + }, + }, + { + Name: "Stack depth limit exceeded", SetUpScript: []string{ - "create table companies (id int primary key, name text, updated_at timestamp);", + "CREATE TABLE test (pk INT PRIMARY KEY, v1 TEXT);", + "CREATE TABLE test2 (pk INT PRIMARY KEY, v1 TEXT);", + `CREATE FUNCTION trigger_func() RETURNS TRIGGER AS $$ +BEGIN + INSERT INTO test2 VALUES (NEW.pk+2, NEW.v1 || '_'); + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE FUNCTION trigger_func2() RETURNS TRIGGER AS $$ +BEGIN + INSERT INTO test VALUES (NEW.pk+4, NEW.v1 || '|'); + RETURN NEW; +END; +$$ LANGUAGE plpgsql;`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test FOR EACH ROW EXECUTE FUNCTION trigger_func();`, + `CREATE TRIGGER test_trigger BEFORE INSERT ON test2 FOR EACH ROW EXECUTE FUNCTION trigger_func2();`, }, Assertions: []ScriptTestAssertion{ { - Query: "CREATE TRIGGER set_public_companies_updated_at BEFORE UPDATE ON public.companies " + - "FOR EACH ROW EXECUTE FUNCTION public.set_current_timestamp_updated_at();", - ExpectedErr: "not yet supported", // we just want to make sure that we can parse the statement successfully + Query: "INSERT INTO test VALUES (1, 'hi'), (2, 'there');", + Skip: true, // TODO: currently we'll just run until we run out of memory, need to abort before that + ExpectedErr: "stack depth limit exceeded", }, }, },