diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index 820799eaa90..8f760e50006 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -1416,6 +1416,12 @@ BeginCopy(ParseState *pstate, errmsg("table \"%s\" does not have OIDs", RelationGetRelationName(cstate->rel)))); + /* + * If there are any triggers with transition tables on the named + * relation, we need to be prepared to capture transition tuples. + */ + cstate->transition_capture = MakeTransitionCaptureState(rel->trigdesc); + /* Initialize state for CopyFrom tuple routing. */ if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE) { @@ -1440,14 +1446,6 @@ BeginCopy(ParseState *pstate, cstate->partition_tuple_slot = partition_tuple_slot; /* - * If there are any triggers with transition tables on the named - * relation, we need to be prepared to capture transition tuples - * from child relations too. - */ - cstate->transition_capture = - MakeTransitionCaptureState(rel->trigdesc); - - /* * If we are capturing transition tuples, they may need to be * converted from partition format back to partitioned table * format (this is only ever necessary if a BEFORE trigger @@ -2788,7 +2786,7 @@ CopyFrom(CopyState cstate) pq_endmsgread(); /* Execute AFTER STATEMENT insertion triggers */ - ExecASInsertTriggers(estate, resultRelInfo); + ExecASInsertTriggers(estate, resultRelInfo, cstate->transition_capture); /* Handle queued AFTER triggers */ AfterTriggerEndQuery(estate); @@ -2916,7 +2914,7 @@ CopyFromInsertBatch(CopyState cstate, EState *estate, CommandId mycid, cstate->cur_lineno = firstBufferedLineNo + i; ExecARInsertTriggers(estate, resultRelInfo, bufferedTuples[i], - NIL, NULL); + NIL, cstate->transition_capture); } } diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c index d90f0474fa5..31bde8371a7 100644 --- a/src/backend/commands/trigger.c +++ b/src/backend/commands/trigger.c @@ -2071,9 +2071,10 @@ FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc) /* * Make a TransitionCaptureState object from a given TriggerDesc. The * resulting object holds the flags which control whether transition tuples - * are collected when tables are modified. This allows us to use the flags - * from a parent table to control the collection of transition tuples from - * child tables. + * are collected when tables are modified, and the tuplestores themselves. + * Note that we copy the flags from a parent table into this struct (rather + * than using each relation's TriggerDesc directly) so that we can use it to + * control the collection of transition tuples from child tables. * * If there are no triggers with transition tables configured for 'trigdesc', * then return NULL. @@ -2091,17 +2092,49 @@ MakeTransitionCaptureState(TriggerDesc *trigdesc) (trigdesc->trig_delete_old_table || trigdesc->trig_update_old_table || trigdesc->trig_update_new_table || trigdesc->trig_insert_new_table)) { + MemoryContext oldcxt; + ResourceOwner saveResourceOwner; + + oldcxt = MemoryContextSwitchTo(TopTransactionContext); + saveResourceOwner = CurrentResourceOwner; + state = (TransitionCaptureState *) palloc0(sizeof(TransitionCaptureState)); state->tcs_delete_old_table = trigdesc->trig_delete_old_table; state->tcs_update_old_table = trigdesc->trig_update_old_table; state->tcs_update_new_table = trigdesc->trig_update_new_table; state->tcs_insert_new_table = trigdesc->trig_insert_new_table; + PG_TRY(); + { + CurrentResourceOwner = TopTransactionResourceOwner; + if (trigdesc->trig_delete_old_table || trigdesc->trig_update_old_table) + state->tcs_old_tuplestore = tuplestore_begin_heap(false, false, work_mem); + if (trigdesc->trig_insert_new_table || trigdesc->trig_update_new_table) + state->tcs_new_tuplestore = tuplestore_begin_heap(false, false, work_mem); + } + PG_CATCH(); + { + CurrentResourceOwner = saveResourceOwner; + PG_RE_THROW(); + } + PG_END_TRY(); + CurrentResourceOwner = saveResourceOwner; + MemoryContextSwitchTo(oldcxt); } return state; } +void +DestroyTransitionCaptureState(TransitionCaptureState *tcs) +{ + if (tcs->tcs_new_tuplestore != NULL) + tuplestore_end(tcs->tcs_new_tuplestore); + if (tcs->tcs_old_tuplestore != NULL) + tuplestore_end(tcs->tcs_old_tuplestore); + pfree(tcs); +} + /* * Call a trigger function. * @@ -2260,13 +2293,14 @@ ExecBSInsertTriggers(EState *estate, ResultRelInfo *relinfo) } void -ExecASInsertTriggers(EState *estate, ResultRelInfo *relinfo) +ExecASInsertTriggers(EState *estate, ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture) { TriggerDesc *trigdesc = relinfo->ri_TrigDesc; if (trigdesc && trigdesc->trig_insert_after_statement) AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_INSERT, - false, NULL, NULL, NIL, NULL, NULL); + false, NULL, NULL, NIL, NULL, transition_capture); } TupleTableSlot * @@ -2470,13 +2504,14 @@ ExecBSDeleteTriggers(EState *estate, ResultRelInfo *relinfo) } void -ExecASDeleteTriggers(EState *estate, ResultRelInfo *relinfo) +ExecASDeleteTriggers(EState *estate, ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture) { TriggerDesc *trigdesc = relinfo->ri_TrigDesc; if (trigdesc && trigdesc->trig_delete_after_statement) AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_DELETE, - false, NULL, NULL, NIL, NULL, NULL); + false, NULL, NULL, NIL, NULL, transition_capture); } bool @@ -2684,7 +2719,8 @@ ExecBSUpdateTriggers(EState *estate, ResultRelInfo *relinfo) } void -ExecASUpdateTriggers(EState *estate, ResultRelInfo *relinfo) +ExecASUpdateTriggers(EState *estate, ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture) { TriggerDesc *trigdesc = relinfo->ri_TrigDesc; @@ -2692,7 +2728,7 @@ ExecASUpdateTriggers(EState *estate, ResultRelInfo *relinfo) AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE, false, NULL, NULL, NIL, GetUpdatedColumns(relinfo, estate), - NULL); + transition_capture); } TupleTableSlot * @@ -3363,6 +3399,7 @@ typedef struct AfterTriggerSharedData Oid ats_tgoid; /* the trigger's ID */ Oid ats_relid; /* the relation it's on */ CommandId ats_firing_id; /* ID for firing cycle */ + TransitionCaptureState *ats_transition_capture; } AfterTriggerSharedData; typedef struct AfterTriggerEventData *AfterTriggerEvent; @@ -3468,9 +3505,6 @@ typedef struct AfterTriggerEventList * fdw_tuplestores[query_depth] is a tuplestore containing the foreign tuples * needed for the current query. * - * old_tuplestores[query_depth] and new_tuplestores[query_depth] hold the - * transition relations for the current query. - * * maxquerydepth is just the allocated length of query_stack and the * tuplestores. * @@ -3503,8 +3537,6 @@ typedef struct AfterTriggersData AfterTriggerEventList *query_stack; /* events pending from each query */ Tuplestorestate **fdw_tuplestores; /* foreign tuples for one row from * each query */ - Tuplestorestate **old_tuplestores; /* all old tuples from each query */ - Tuplestorestate **new_tuplestores; /* all new tuples from each query */ int maxquerydepth; /* allocated len of above array */ MemoryContext event_cxt; /* memory context for events, if any */ @@ -3525,7 +3557,8 @@ static void AfterTriggerExecute(AfterTriggerEvent event, Instrumentation *instr, MemoryContext per_tuple_context, TupleTableSlot *trig_tuple_slot1, - TupleTableSlot *trig_tuple_slot2); + TupleTableSlot *trig_tuple_slot2, + TransitionCaptureState *transition_capture); static SetConstraintState SetConstraintStateCreate(int numalloc); static SetConstraintState SetConstraintStateCopy(SetConstraintState state); static SetConstraintState SetConstraintStateAddItem(SetConstraintState state, @@ -3534,8 +3567,6 @@ static SetConstraintState SetConstraintStateAddItem(SetConstraintState state, /* * Gets a current query transition tuplestore and initializes it if necessary. - * This can be holding a single transition row tuple (in the case of an FDW) - * or a transition table (for an AFTER trigger). */ static Tuplestorestate * GetTriggerTransitionTuplestore(Tuplestorestate **tss) @@ -3715,6 +3746,7 @@ afterTriggerAddEvent(AfterTriggerEventList *events, if (newshared->ats_tgoid == evtshared->ats_tgoid && newshared->ats_relid == evtshared->ats_relid && newshared->ats_event == evtshared->ats_event && + newshared->ats_transition_capture == evtshared->ats_transition_capture && newshared->ats_firing_id == 0) break; } @@ -3826,7 +3858,8 @@ AfterTriggerExecute(AfterTriggerEvent event, FmgrInfo *finfo, Instrumentation *instr, MemoryContext per_tuple_context, TupleTableSlot *trig_tuple_slot1, - TupleTableSlot *trig_tuple_slot2) + TupleTableSlot *trig_tuple_slot2, + TransitionCaptureState *transition_capture) { AfterTriggerShared evtshared = GetTriggerSharedData(event); Oid tgoid = evtshared->ats_tgoid; @@ -3941,16 +3974,14 @@ AfterTriggerExecute(AfterTriggerEvent event, /* * Set up the tuplestore information. */ - if (LocTriggerData.tg_trigger->tgoldtable) - LocTriggerData.tg_oldtable = - GetTriggerTransitionTuplestore(afterTriggers.old_tuplestores); - else - LocTriggerData.tg_oldtable = NULL; - if (LocTriggerData.tg_trigger->tgnewtable) - LocTriggerData.tg_newtable = - GetTriggerTransitionTuplestore(afterTriggers.new_tuplestores); - else - LocTriggerData.tg_newtable = NULL; + LocTriggerData.tg_oldtable = LocTriggerData.tg_newtable = NULL; + if (transition_capture != NULL) + { + if (LocTriggerData.tg_trigger->tgoldtable) + LocTriggerData.tg_oldtable = transition_capture->tcs_old_tuplestore; + if (LocTriggerData.tg_trigger->tgnewtable) + LocTriggerData.tg_newtable = transition_capture->tcs_new_tuplestore; + } /* * Setup the remaining trigger information @@ -4158,7 +4189,8 @@ afterTriggerInvokeEvents(AfterTriggerEventList *events, * won't try to re-fire it. */ AfterTriggerExecute(event, rel, trigdesc, finfo, instr, - per_tuple_context, slot1, slot2); + per_tuple_context, slot1, slot2, + evtshared->ats_transition_capture); /* * Mark the event as done. @@ -4232,8 +4264,6 @@ AfterTriggerBeginXact(void) Assert(afterTriggers.state == NULL); Assert(afterTriggers.query_stack == NULL); Assert(afterTriggers.fdw_tuplestores == NULL); - Assert(afterTriggers.old_tuplestores == NULL); - Assert(afterTriggers.new_tuplestores == NULL); Assert(afterTriggers.maxquerydepth == 0); Assert(afterTriggers.event_cxt == NULL); Assert(afterTriggers.events.head == NULL); @@ -4278,8 +4308,6 @@ AfterTriggerEndQuery(EState *estate) { AfterTriggerEventList *events; Tuplestorestate *fdw_tuplestore; - Tuplestorestate *old_tuplestore; - Tuplestorestate *new_tuplestore; /* Must be inside a query, too */ Assert(afterTriggers.query_depth >= 0); @@ -4338,18 +4366,6 @@ AfterTriggerEndQuery(EState *estate) tuplestore_end(fdw_tuplestore); afterTriggers.fdw_tuplestores[afterTriggers.query_depth] = NULL; } - old_tuplestore = afterTriggers.old_tuplestores[afterTriggers.query_depth]; - if (old_tuplestore) - { - tuplestore_end(old_tuplestore); - afterTriggers.old_tuplestores[afterTriggers.query_depth] = NULL; - } - new_tuplestore = afterTriggers.new_tuplestores[afterTriggers.query_depth]; - if (new_tuplestore) - { - tuplestore_end(new_tuplestore); - afterTriggers.new_tuplestores[afterTriggers.query_depth] = NULL; - } afterTriggerFreeEventList(&afterTriggers.query_stack[afterTriggers.query_depth]); afterTriggers.query_depth--; @@ -4463,8 +4479,6 @@ AfterTriggerEndXact(bool isCommit) */ afterTriggers.query_stack = NULL; afterTriggers.fdw_tuplestores = NULL; - afterTriggers.old_tuplestores = NULL; - afterTriggers.new_tuplestores = NULL; afterTriggers.maxquerydepth = 0; afterTriggers.state = NULL; @@ -4597,18 +4611,6 @@ AfterTriggerEndSubXact(bool isCommit) tuplestore_end(ts); afterTriggers.fdw_tuplestores[afterTriggers.query_depth] = NULL; } - ts = afterTriggers.old_tuplestores[afterTriggers.query_depth]; - if (ts) - { - tuplestore_end(ts); - afterTriggers.old_tuplestores[afterTriggers.query_depth] = NULL; - } - ts = afterTriggers.new_tuplestores[afterTriggers.query_depth]; - if (ts) - { - tuplestore_end(ts); - afterTriggers.new_tuplestores[afterTriggers.query_depth] = NULL; - } afterTriggerFreeEventList(&afterTriggers.query_stack[afterTriggers.query_depth]); } @@ -4688,12 +4690,6 @@ AfterTriggerEnlargeQueryState(void) afterTriggers.fdw_tuplestores = (Tuplestorestate **) MemoryContextAllocZero(TopTransactionContext, new_alloc * sizeof(Tuplestorestate *)); - afterTriggers.old_tuplestores = (Tuplestorestate **) - MemoryContextAllocZero(TopTransactionContext, - new_alloc * sizeof(Tuplestorestate *)); - afterTriggers.new_tuplestores = (Tuplestorestate **) - MemoryContextAllocZero(TopTransactionContext, - new_alloc * sizeof(Tuplestorestate *)); afterTriggers.maxquerydepth = new_alloc; } else @@ -4709,19 +4705,9 @@ AfterTriggerEnlargeQueryState(void) afterTriggers.fdw_tuplestores = (Tuplestorestate **) repalloc(afterTriggers.fdw_tuplestores, new_alloc * sizeof(Tuplestorestate *)); - afterTriggers.old_tuplestores = (Tuplestorestate **) - repalloc(afterTriggers.old_tuplestores, - new_alloc * sizeof(Tuplestorestate *)); - afterTriggers.new_tuplestores = (Tuplestorestate **) - repalloc(afterTriggers.new_tuplestores, - new_alloc * sizeof(Tuplestorestate *)); /* Clear newly-allocated slots for subsequent lazy initialization. */ memset(afterTriggers.fdw_tuplestores + old_alloc, 0, (new_alloc - old_alloc) * sizeof(Tuplestorestate *)); - memset(afterTriggers.old_tuplestores + old_alloc, - 0, (new_alloc - old_alloc) * sizeof(Tuplestorestate *)); - memset(afterTriggers.new_tuplestores + old_alloc, - 0, (new_alloc - old_alloc) * sizeof(Tuplestorestate *)); afterTriggers.maxquerydepth = new_alloc; } @@ -5255,42 +5241,39 @@ AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo, if ((event == TRIGGER_EVENT_DELETE && delete_old_table) || (event == TRIGGER_EVENT_UPDATE && update_old_table)) { - Tuplestorestate *old_tuplestore; - Assert(oldtup != NULL); - old_tuplestore = - GetTriggerTransitionTuplestore - (afterTriggers.old_tuplestores); + if (map != NULL) { HeapTuple converted = do_convert_tuple(oldtup, map); - tuplestore_puttuple(old_tuplestore, converted); + tuplestore_puttuple(transition_capture->tcs_old_tuplestore, + converted); pfree(converted); } else - tuplestore_puttuple(old_tuplestore, oldtup); + tuplestore_puttuple(transition_capture->tcs_old_tuplestore, + oldtup); } if ((event == TRIGGER_EVENT_INSERT && insert_new_table) || (event == TRIGGER_EVENT_UPDATE && update_new_table)) { - Tuplestorestate *new_tuplestore; - Assert(newtup != NULL); - new_tuplestore = - GetTriggerTransitionTuplestore - (afterTriggers.new_tuplestores); + if (original_insert_tuple != NULL) - tuplestore_puttuple(new_tuplestore, original_insert_tuple); + tuplestore_puttuple(transition_capture->tcs_new_tuplestore, + original_insert_tuple); else if (map != NULL) { HeapTuple converted = do_convert_tuple(newtup, map); - tuplestore_puttuple(new_tuplestore, converted); + tuplestore_puttuple(transition_capture->tcs_new_tuplestore, + converted); pfree(converted); } else - tuplestore_puttuple(new_tuplestore, newtup); + tuplestore_puttuple(transition_capture->tcs_new_tuplestore, + newtup); } /* If transition tables are the only reason we're here, return. */ @@ -5465,6 +5448,7 @@ AfterTriggerSaveEvent(EState *estate, ResultRelInfo *relinfo, new_shared.ats_tgoid = trigger->tgoid; new_shared.ats_relid = RelationGetRelid(rel); new_shared.ats_firing_id = 0; + new_shared.ats_transition_capture = transition_capture; afterTriggerAddEvent(&afterTriggers.query_stack[afterTriggers.query_depth], &new_event, &new_shared); diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index 6eb979f17da..2bacf66ac48 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -1420,14 +1420,18 @@ fireASTriggers(ModifyTableState *node) case CMD_INSERT: if (node->mt_onconflict == ONCONFLICT_UPDATE) ExecASUpdateTriggers(node->ps.state, - resultRelInfo); - ExecASInsertTriggers(node->ps.state, resultRelInfo); + resultRelInfo, + node->mt_transition_capture); + ExecASInsertTriggers(node->ps.state, resultRelInfo, + node->mt_transition_capture); break; case CMD_UPDATE: - ExecASUpdateTriggers(node->ps.state, resultRelInfo); + ExecASUpdateTriggers(node->ps.state, resultRelInfo, + node->mt_transition_capture); break; case CMD_DELETE: - ExecASDeleteTriggers(node->ps.state, resultRelInfo); + ExecASDeleteTriggers(node->ps.state, resultRelInfo, + node->mt_transition_capture); break; default: elog(ERROR, "unknown operation"); @@ -2272,6 +2276,10 @@ ExecEndModifyTable(ModifyTableState *node) { int i; + /* Free transition tables */ + if (node->mt_transition_capture != NULL) + DestroyTransitionCaptureState(node->mt_transition_capture); + /* * Allow any FDWs to shut down */ diff --git a/src/include/commands/trigger.h b/src/include/commands/trigger.h index 736f5de67dd..5ce57966245 100644 --- a/src/include/commands/trigger.h +++ b/src/include/commands/trigger.h @@ -42,8 +42,8 @@ typedef struct TriggerData } TriggerData; /* - * Meta-data to control the capture of old and new tuples into transition - * tables from child tables. + * The state for capturing old and new tuples into transition tables for a + * single ModifyTable node. */ typedef struct TransitionCaptureState { @@ -72,6 +72,10 @@ typedef struct TransitionCaptureState * the original tuple directly. */ HeapTuple tcs_original_insert_tuple; + + /* The tuplestores backing the transition tables. */ + Tuplestorestate *tcs_old_tuplestore; + Tuplestorestate *tcs_new_tuplestore; } TransitionCaptureState; /* @@ -162,13 +166,15 @@ extern TriggerDesc *CopyTriggerDesc(TriggerDesc *trigdesc); extern const char *FindTriggerIncompatibleWithInheritance(TriggerDesc *trigdesc); extern TransitionCaptureState *MakeTransitionCaptureState(TriggerDesc *trigdesc); +extern void DestroyTransitionCaptureState(TransitionCaptureState *tcs); extern void FreeTriggerDesc(TriggerDesc *trigdesc); extern void ExecBSInsertTriggers(EState *estate, ResultRelInfo *relinfo); extern void ExecASInsertTriggers(EState *estate, - ResultRelInfo *relinfo); + ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture); extern TupleTableSlot *ExecBRInsertTriggers(EState *estate, ResultRelInfo *relinfo, TupleTableSlot *slot); @@ -183,7 +189,8 @@ extern TupleTableSlot *ExecIRInsertTriggers(EState *estate, extern void ExecBSDeleteTriggers(EState *estate, ResultRelInfo *relinfo); extern void ExecASDeleteTriggers(EState *estate, - ResultRelInfo *relinfo); + ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture); extern bool ExecBRDeleteTriggers(EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, @@ -200,7 +207,8 @@ extern bool ExecIRDeleteTriggers(EState *estate, extern void ExecBSUpdateTriggers(EState *estate, ResultRelInfo *relinfo); extern void ExecASUpdateTriggers(EState *estate, - ResultRelInfo *relinfo); + ResultRelInfo *relinfo, + TransitionCaptureState *transition_capture); extern TupleTableSlot *ExecBRUpdateTriggers(EState *estate, EPQState *epqstate, ResultRelInfo *relinfo, diff --git a/src/test/regress/expected/triggers.out b/src/test/regress/expected/triggers.out index 2b5695f5792..9eab7c38f8f 100644 --- a/src/test/regress/expected/triggers.out +++ b/src/test/regress/expected/triggers.out @@ -2140,5 +2140,29 @@ DETAIL: ROW triggers with transition tables are not supported in inheritance hi drop trigger child_row_trig on child; alter table child inherit parent; drop table child, parent; +-- +-- Verify behavior of queries with wCTEs, where multiple transition +-- tuplestores can be active at the same time because there are +-- multiple DML statements that might fire triggers with transition +-- tables +-- +create table table1 (a int); +create table table2 (a text); +create trigger table1_trig + after insert or update or delete on table1 + referencing old table as old_table new table as new_table + for each statement + execute procedure dump_transition_tables(); +create trigger table2_trig + after insert or update or delete on table2 + referencing old table as old_table new table as new_table + for each statement + execute procedure dump_transition_tables(); +with wcte as (insert into table1 values (42)) + insert into table2 values ('hello world'); +NOTICE: trigger = table2_trig, old table = , new table = ("hello world") +NOTICE: trigger = table1_trig, old table = , new table = (42) +drop table table1; +drop table table2; -- cleanup drop function dump_transition_tables(); diff --git a/src/test/regress/sql/triggers.sql b/src/test/regress/sql/triggers.sql index 14f25f85e15..14a1d4b0de1 100644 --- a/src/test/regress/sql/triggers.sql +++ b/src/test/regress/sql/triggers.sql @@ -1648,5 +1648,30 @@ alter table child inherit parent; drop table child, parent; +-- +-- Verify behavior of queries with wCTEs, where multiple transition +-- tuplestores can be active at the same time because there are +-- multiple DML statements that might fire triggers with transition +-- tables +-- +create table table1 (a int); +create table table2 (a text); +create trigger table1_trig + after insert or update or delete on table1 + referencing old table as old_table new table as new_table + for each statement + execute procedure dump_transition_tables(); +create trigger table2_trig + after insert or update or delete on table2 + referencing old table as old_table new table as new_table + for each statement + execute procedure dump_transition_tables(); + +with wcte as (insert into table1 values (42)) + insert into table2 values ('hello world'); + +drop table table1; +drop table table2; + -- cleanup drop function dump_transition_tables();