Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * nodeModifyTable.c
4 : * routines to handle ModifyTable nodes.
5 : *
6 : * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/executor/nodeModifyTable.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : /* INTERFACE ROUTINES
16 : * ExecInitModifyTable - initialize the ModifyTable node
17 : * ExecModifyTable - retrieve the next tuple from the node
18 : * ExecEndModifyTable - shut down the ModifyTable node
19 : * ExecReScanModifyTable - rescan the ModifyTable node
20 : *
21 : * NOTES
22 : * Each ModifyTable node contains a list of one or more subplans,
23 : * much like an Append node. There is one subplan per result relation.
24 : * The key reason for this is that in an inherited UPDATE command, each
25 : * result relation could have a different schema (more or different
26 : * columns) requiring a different plan tree to produce it. In an
27 : * inherited DELETE, all the subplans should produce the same output
28 : * rowtype, but we might still find that different plans are appropriate
29 : * for different child relations.
30 : *
31 : * If the query specifies RETURNING, then the ModifyTable returns a
32 : * RETURNING tuple after completing each row insert, update, or delete.
33 : * It must be called again to continue the operation. Without RETURNING,
34 : * we just loop within the node until all the work is done, then
35 : * return NULL. This avoids useless call/return overhead.
36 : */
37 :
38 : #include "postgres.h"
39 :
40 : #include "access/heapam.h"
41 : #include "access/htup_details.h"
42 : #include "access/tableam.h"
43 : #include "access/xact.h"
44 : #include "catalog/catalog.h"
45 : #include "commands/trigger.h"
46 : #include "executor/execPartition.h"
47 : #include "executor/executor.h"
48 : #include "executor/nodeModifyTable.h"
49 : #include "foreign/fdwapi.h"
50 : #include "miscadmin.h"
51 : #include "nodes/nodeFuncs.h"
52 : #include "rewrite/rewriteHandler.h"
53 : #include "storage/bufmgr.h"
54 : #include "storage/lmgr.h"
55 : #include "utils/builtins.h"
56 : #include "utils/datum.h"
57 : #include "utils/memutils.h"
58 : #include "utils/rel.h"
59 :
60 :
61 : static bool ExecOnConflictUpdate(ModifyTableState *mtstate,
62 : ResultRelInfo *resultRelInfo,
63 : ItemPointer conflictTid,
64 : TupleTableSlot *planSlot,
65 : TupleTableSlot *excludedSlot,
66 : EState *estate,
67 : bool canSetTag,
68 : TupleTableSlot **returning);
69 : static TupleTableSlot *ExecPrepareTupleRouting(ModifyTableState *mtstate,
70 : EState *estate,
71 : PartitionTupleRouting *proute,
72 : ResultRelInfo *targetRelInfo,
73 : TupleTableSlot *slot);
74 : static ResultRelInfo *getTargetResultRelInfo(ModifyTableState *node);
75 : static void ExecSetupChildParentMapForSubplan(ModifyTableState *mtstate);
76 : static TupleConversionMap *tupconv_map_for_subplan(ModifyTableState *node,
77 : int whichplan);
78 :
79 : /*
80 : * Verify that the tuples to be produced by INSERT or UPDATE match the
81 : * target relation's rowtype
82 : *
83 : * We do this to guard against stale plans. If plan invalidation is
84 : * functioning properly then we should never get a failure here, but better
85 : * safe than sorry. Note that this is called after we have obtained lock
86 : * on the target rel, so the rowtype can't change underneath us.
87 : *
88 : * The plan output is represented by its targetlist, because that makes
89 : * handling the dropped-column case easier.
90 : */
91 : static void
92 74844 : ExecCheckPlanOutput(Relation resultRel, List *targetList)
93 : {
94 74844 : TupleDesc resultDesc = RelationGetDescr(resultRel);
95 74844 : int attno = 0;
96 : ListCell *lc;
97 :
98 438828 : foreach(lc, targetList)
99 : {
100 363984 : TargetEntry *tle = (TargetEntry *) lfirst(lc);
101 : Form_pg_attribute attr;
102 :
103 363984 : if (tle->resjunk)
104 11666 : continue; /* ignore junk tlist items */
105 :
106 352318 : if (attno >= resultDesc->natts)
107 0 : ereport(ERROR,
108 : (errcode(ERRCODE_DATATYPE_MISMATCH),
109 : errmsg("table row type and query-specified row type do not match"),
110 : errdetail("Query has too many columns.")));
111 352318 : attr = TupleDescAttr(resultDesc, attno);
112 352318 : attno++;
113 :
114 352318 : if (!attr->attisdropped)
115 : {
116 : /* Normal case: demand type match */
117 351764 : if (exprType((Node *) tle->expr) != attr->atttypid)
118 0 : ereport(ERROR,
119 : (errcode(ERRCODE_DATATYPE_MISMATCH),
120 : errmsg("table row type and query-specified row type do not match"),
121 : errdetail("Table has type %s at ordinal position %d, but query expects %s.",
122 : format_type_be(attr->atttypid),
123 : attno,
124 : format_type_be(exprType((Node *) tle->expr)))));
125 : }
126 : else
127 : {
128 : /*
129 : * For a dropped column, we can't check atttypid (it's likely 0).
130 : * In any case the planner has most likely inserted an INT4 null.
131 : * What we insist on is just *some* NULL constant.
132 : */
133 1108 : if (!IsA(tle->expr, Const) ||
134 554 : !((Const *) tle->expr)->constisnull)
135 0 : ereport(ERROR,
136 : (errcode(ERRCODE_DATATYPE_MISMATCH),
137 : errmsg("table row type and query-specified row type do not match"),
138 : errdetail("Query provides a value for a dropped column at ordinal position %d.",
139 : attno)));
140 : }
141 : }
142 74844 : if (attno != resultDesc->natts)
143 0 : ereport(ERROR,
144 : (errcode(ERRCODE_DATATYPE_MISMATCH),
145 : errmsg("table row type and query-specified row type do not match"),
146 : errdetail("Query has too few columns.")));
147 74844 : }
148 :
149 : /*
150 : * ExecProcessReturning --- evaluate a RETURNING list
151 : *
152 : * resultRelInfo: current result rel
153 : * tupleSlot: slot holding tuple actually inserted/updated/deleted
154 : * planSlot: slot holding tuple returned by top subplan node
155 : *
156 : * Note: If tupleSlot is NULL, the FDW should have already provided econtext's
157 : * scan tuple.
158 : *
159 : * Returns a slot holding the result tuple
160 : */
161 : static TupleTableSlot *
162 4034 : ExecProcessReturning(ResultRelInfo *resultRelInfo,
163 : TupleTableSlot *tupleSlot,
164 : TupleTableSlot *planSlot)
165 : {
166 4034 : ProjectionInfo *projectReturning = resultRelInfo->ri_projectReturning;
167 4034 : ExprContext *econtext = projectReturning->pi_exprContext;
168 :
169 : /* Make tuple and any needed join variables available to ExecProject */
170 4034 : if (tupleSlot)
171 3342 : econtext->ecxt_scantuple = tupleSlot;
172 4034 : econtext->ecxt_outertuple = planSlot;
173 :
174 : /*
175 : * RETURNING expressions might reference the tableoid column, so
176 : * reinitialize tts_tableOid before evaluating them.
177 : */
178 8068 : econtext->ecxt_scantuple->tts_tableOid =
179 4034 : RelationGetRelid(resultRelInfo->ri_RelationDesc);
180 :
181 : /* Compute the RETURNING expressions */
182 4034 : return ExecProject(projectReturning);
183 : }
184 :
185 : /*
186 : * ExecCheckTupleVisible -- verify tuple is visible
187 : *
188 : * It would not be consistent with guarantees of the higher isolation levels to
189 : * proceed with avoiding insertion (taking speculative insertion's alternative
190 : * path) on the basis of another tuple that is not visible to MVCC snapshot.
191 : * Check for the need to raise a serialization failure, and do so as necessary.
192 : */
193 : static void
194 4972 : ExecCheckTupleVisible(EState *estate,
195 : Relation rel,
196 : TupleTableSlot *slot)
197 : {
198 4972 : if (!IsolationUsesXactSnapshot())
199 4912 : return;
200 :
201 60 : if (!table_tuple_satisfies_snapshot(rel, slot, estate->es_snapshot))
202 : {
203 : Datum xminDatum;
204 : TransactionId xmin;
205 : bool isnull;
206 :
207 36 : xminDatum = slot_getsysattr(slot, MinTransactionIdAttributeNumber, &isnull);
208 : Assert(!isnull);
209 36 : xmin = DatumGetTransactionId(xminDatum);
210 :
211 : /*
212 : * We should not raise a serialization failure if the conflict is
213 : * against a tuple inserted by our own transaction, even if it's not
214 : * visible to our snapshot. (This would happen, for example, if
215 : * conflicting keys are proposed for insertion in a single command.)
216 : */
217 36 : if (!TransactionIdIsCurrentTransactionId(xmin))
218 20 : ereport(ERROR,
219 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
220 : errmsg("could not serialize access due to concurrent update")));
221 : }
222 : }
223 :
224 : /*
225 : * ExecCheckTIDVisible -- convenience variant of ExecCheckTupleVisible()
226 : */
227 : static void
228 122 : ExecCheckTIDVisible(EState *estate,
229 : ResultRelInfo *relinfo,
230 : ItemPointer tid,
231 : TupleTableSlot *tempSlot)
232 : {
233 122 : Relation rel = relinfo->ri_RelationDesc;
234 :
235 : /* Redundantly check isolation level */
236 122 : if (!IsolationUsesXactSnapshot())
237 62 : return;
238 :
239 60 : if (!table_tuple_fetch_row_version(rel, tid, SnapshotAny, tempSlot))
240 0 : elog(ERROR, "failed to fetch conflicting tuple for ON CONFLICT");
241 60 : ExecCheckTupleVisible(estate, rel, tempSlot);
242 40 : ExecClearTuple(tempSlot);
243 : }
244 :
245 : /*
246 : * Compute stored generated columns for a tuple
247 : */
248 : void
249 334 : ExecComputeStoredGenerated(EState *estate, TupleTableSlot *slot)
250 : {
251 334 : ResultRelInfo *resultRelInfo = estate->es_result_relation_info;
252 334 : Relation rel = resultRelInfo->ri_RelationDesc;
253 334 : TupleDesc tupdesc = RelationGetDescr(rel);
254 334 : int natts = tupdesc->natts;
255 : MemoryContext oldContext;
256 : Datum *values;
257 : bool *nulls;
258 :
259 : Assert(tupdesc->constr && tupdesc->constr->has_generated_stored);
260 :
261 : /*
262 : * If first time through for this result relation, build expression
263 : * nodetrees for rel's stored generation expressions. Keep them in the
264 : * per-query memory context so they'll survive throughout the query.
265 : */
266 334 : if (resultRelInfo->ri_GeneratedExprs == NULL)
267 : {
268 230 : oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
269 :
270 230 : resultRelInfo->ri_GeneratedExprs =
271 230 : (ExprState **) palloc(natts * sizeof(ExprState *));
272 :
273 702 : for (int i = 0; i < natts; i++)
274 : {
275 472 : if (TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_STORED)
276 : {
277 : Expr *expr;
278 :
279 230 : expr = (Expr *) build_column_default(rel, i + 1);
280 230 : if (expr == NULL)
281 0 : elog(ERROR, "no generation expression found for column number %d of table \"%s\"",
282 : i + 1, RelationGetRelationName(rel));
283 :
284 230 : resultRelInfo->ri_GeneratedExprs[i] = ExecPrepareExpr(expr, estate);
285 : }
286 : }
287 :
288 230 : MemoryContextSwitchTo(oldContext);
289 : }
290 :
291 334 : oldContext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
292 :
293 334 : values = palloc(sizeof(*values) * natts);
294 334 : nulls = palloc(sizeof(*nulls) * natts);
295 :
296 334 : slot_getallattrs(slot);
297 334 : memcpy(nulls, slot->tts_isnull, sizeof(*nulls) * natts);
298 :
299 1014 : for (int i = 0; i < natts; i++)
300 : {
301 688 : Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
302 :
303 688 : if (attr->attgenerated == ATTRIBUTE_GENERATED_STORED)
304 : {
305 : ExprContext *econtext;
306 : Datum val;
307 : bool isnull;
308 :
309 334 : econtext = GetPerTupleExprContext(estate);
310 334 : econtext->ecxt_scantuple = slot;
311 :
312 334 : val = ExecEvalExpr(resultRelInfo->ri_GeneratedExprs[i], econtext, &isnull);
313 :
314 326 : values[i] = val;
315 326 : nulls[i] = isnull;
316 : }
317 : else
318 : {
319 354 : if (!nulls[i])
320 346 : values[i] = datumCopy(slot->tts_values[i], attr->attbyval, attr->attlen);
321 : }
322 : }
323 :
324 326 : ExecClearTuple(slot);
325 326 : memcpy(slot->tts_values, values, sizeof(*values) * natts);
326 326 : memcpy(slot->tts_isnull, nulls, sizeof(*nulls) * natts);
327 326 : ExecStoreVirtualTuple(slot);
328 326 : ExecMaterializeSlot(slot);
329 :
330 326 : MemoryContextSwitchTo(oldContext);
331 326 : }
332 :
333 : /* ----------------------------------------------------------------
334 : * ExecInsert
335 : *
336 : * For INSERT, we have to insert the tuple into the target relation
337 : * and insert appropriate tuples into the index relations.
338 : *
339 : * Returns RETURNING result if any, otherwise NULL.
340 : * ----------------------------------------------------------------
341 : */
342 : static TupleTableSlot *
343 11257644 : ExecInsert(ModifyTableState *mtstate,
344 : TupleTableSlot *slot,
345 : TupleTableSlot *planSlot,
346 : EState *estate,
347 : bool canSetTag)
348 : {
349 : ResultRelInfo *resultRelInfo;
350 : Relation resultRelationDesc;
351 11257644 : List *recheckIndexes = NIL;
352 11257644 : TupleTableSlot *result = NULL;
353 : TransitionCaptureState *ar_insert_trig_tcs;
354 11257644 : ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
355 11257644 : OnConflictAction onconflict = node->onConflictAction;
356 :
357 11257644 : ExecMaterializeSlot(slot);
358 :
359 : /*
360 : * get information on the (current) result relation
361 : */
362 11257644 : resultRelInfo = estate->es_result_relation_info;
363 11257644 : resultRelationDesc = resultRelInfo->ri_RelationDesc;
364 :
365 : /*
366 : * BEFORE ROW INSERT Triggers.
367 : *
368 : * Note: We fire BEFORE ROW TRIGGERS for every attempted insertion in an
369 : * INSERT ... ON CONFLICT statement. We cannot check for constraint
370 : * violations before firing these triggers, because they can change the
371 : * values to insert. Also, they can run arbitrary user-defined code with
372 : * side-effects that we can't cancel by just not inserting the tuple.
373 : */
374 11306588 : if (resultRelInfo->ri_TrigDesc &&
375 48944 : resultRelInfo->ri_TrigDesc->trig_insert_before_row)
376 : {
377 1178 : if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))
378 16 : return NULL; /* "do nothing" */
379 : }
380 :
381 : /* INSTEAD OF ROW INSERT Triggers */
382 11306420 : if (resultRelInfo->ri_TrigDesc &&
383 48860 : resultRelInfo->ri_TrigDesc->trig_insert_instead_row)
384 : {
385 184 : if (!ExecIRInsertTriggers(estate, resultRelInfo, slot))
386 4 : return NULL; /* "do nothing" */
387 : }
388 11257466 : else if (resultRelInfo->ri_FdwRoutine)
389 : {
390 : /*
391 : * Compute stored generated columns
392 : */
393 752 : if (resultRelationDesc->rd_att->constr &&
394 360 : resultRelationDesc->rd_att->constr->has_generated_stored)
395 4 : ExecComputeStoredGenerated(estate, slot);
396 :
397 : /*
398 : * insert into foreign table: let the FDW do it
399 : */
400 392 : slot = resultRelInfo->ri_FdwRoutine->ExecForeignInsert(estate,
401 : resultRelInfo,
402 : slot,
403 : planSlot);
404 :
405 386 : if (slot == NULL) /* "do nothing" */
406 4 : return NULL;
407 :
408 : /*
409 : * AFTER ROW Triggers or RETURNING expressions might reference the
410 : * tableoid column, so (re-)initialize tts_tableOid before evaluating
411 : * them.
412 : */
413 382 : slot->tts_tableOid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
414 :
415 : }
416 : else
417 : {
418 : WCOKind wco_kind;
419 :
420 : /*
421 : * Constraints might reference the tableoid column, so (re-)initialize
422 : * tts_tableOid before evaluating them.
423 : */
424 11257074 : slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
425 :
426 : /*
427 : * Compute stored generated columns
428 : */
429 17174588 : if (resultRelationDesc->rd_att->constr &&
430 5917514 : resultRelationDesc->rd_att->constr->has_generated_stored)
431 256 : ExecComputeStoredGenerated(estate, slot);
432 :
433 : /*
434 : * Check any RLS WITH CHECK policies.
435 : *
436 : * Normally we should check INSERT policies. But if the insert is the
437 : * result of a partition key update that moved the tuple to a new
438 : * partition, we should instead check UPDATE policies, because we are
439 : * executing policies defined on the target table, and not those
440 : * defined on the child partitions.
441 : */
442 22514132 : wco_kind = (mtstate->operation == CMD_UPDATE) ?
443 11257066 : WCO_RLS_UPDATE_CHECK : WCO_RLS_INSERT_CHECK;
444 :
445 : /*
446 : * ExecWithCheckOptions() will skip any WCOs which are not of the kind
447 : * we are looking for at this point.
448 : */
449 11257066 : if (resultRelInfo->ri_WithCheckOptions != NIL)
450 336 : ExecWithCheckOptions(wco_kind, resultRelInfo, slot, estate);
451 :
452 : /*
453 : * Check the constraints of the tuple.
454 : */
455 11256954 : if (resultRelationDesc->rd_att->constr)
456 5917458 : ExecConstraints(resultRelInfo, slot, estate);
457 :
458 : /*
459 : * Also check the tuple against the partition constraint, if there is
460 : * one; except that if we got here via tuple-routing, we don't need to
461 : * if there's no BR trigger defined on the partition.
462 : */
463 11547424 : if (resultRelInfo->ri_PartitionCheck &&
464 581274 : (resultRelInfo->ri_PartitionRoot == NULL ||
465 290964 : (resultRelInfo->ri_TrigDesc &&
466 480 : resultRelInfo->ri_TrigDesc->trig_insert_before_row)))
467 398 : ExecPartitionCheck(resultRelInfo, slot, estate, true);
468 :
469 11256526 : if (onconflict != ONCONFLICT_NONE && resultRelInfo->ri_NumIndices > 0)
470 3874 : {
471 : /* Perform a speculative insertion. */
472 : uint32 specToken;
473 : ItemPointerData conflictTid;
474 : bool specConflict;
475 : List *arbiterIndexes;
476 :
477 8932 : arbiterIndexes = resultRelInfo->ri_onConflictArbiterIndexes;
478 :
479 : /*
480 : * Do a non-conclusive check for conflicts first.
481 : *
482 : * We're not holding any locks yet, so this doesn't guarantee that
483 : * the later insert won't conflict. But it avoids leaving behind
484 : * a lot of canceled speculative insertions, if you run a lot of
485 : * INSERT ON CONFLICT statements that do conflict.
486 : *
487 : * We loop back here if we find a conflict below, either during
488 : * the pre-check, or when we re-check after inserting the tuple
489 : * speculatively.
490 : */
491 : vlock:
492 8938 : specConflict = false;
493 8938 : if (!ExecCheckIndexConstraints(slot, estate, &conflictTid,
494 : arbiterIndexes))
495 : {
496 : /* committed conflict tuple found */
497 5050 : if (onconflict == ONCONFLICT_UPDATE)
498 : {
499 : /*
500 : * In case of ON CONFLICT DO UPDATE, execute the UPDATE
501 : * part. Be prepared to retry if the UPDATE fails because
502 : * of another concurrent UPDATE/DELETE to the conflict
503 : * tuple.
504 : */
505 4928 : TupleTableSlot *returning = NULL;
506 :
507 4928 : if (ExecOnConflictUpdate(mtstate, resultRelInfo,
508 : &conflictTid, planSlot, slot,
509 : estate, canSetTag, &returning))
510 : {
511 4876 : InstrCountTuples2(&mtstate->ps, 1);
512 4876 : return returning;
513 : }
514 : else
515 0 : goto vlock;
516 : }
517 : else
518 : {
519 : /*
520 : * In case of ON CONFLICT DO NOTHING, do nothing. However,
521 : * verify that the tuple is visible to the executor's MVCC
522 : * snapshot at higher isolation levels.
523 : *
524 : * Using ExecGetReturningSlot() to store the tuple for the
525 : * recheck isn't that pretty, but we can't trivially use
526 : * the input slot, because it might not be of a compatible
527 : * type. As there's no conflicting usage of
528 : * ExecGetReturningSlot() in the DO NOTHING case...
529 : */
530 : Assert(onconflict == ONCONFLICT_NOTHING);
531 122 : ExecCheckTIDVisible(estate, resultRelInfo, &conflictTid,
532 : ExecGetReturningSlot(estate, resultRelInfo));
533 102 : InstrCountTuples2(&mtstate->ps, 1);
534 102 : return NULL;
535 : }
536 : }
537 :
538 : /*
539 : * Before we start insertion proper, acquire our "speculative
540 : * insertion lock". Others can use that to wait for us to decide
541 : * if we're going to go ahead with the insertion, instead of
542 : * waiting for the whole transaction to complete.
543 : */
544 3884 : specToken = SpeculativeInsertionLockAcquire(GetCurrentTransactionId());
545 :
546 : /* insert the tuple, with the speculative token */
547 3884 : table_tuple_insert_speculative(resultRelationDesc, slot,
548 : estate->es_output_cid,
549 : 0,
550 : NULL,
551 : specToken);
552 :
553 : /* insert index entries for tuple */
554 3884 : recheckIndexes = ExecInsertIndexTuples(slot, estate, true,
555 : &specConflict,
556 : arbiterIndexes);
557 :
558 : /* adjust the tuple's state accordingly */
559 3880 : table_tuple_complete_speculative(resultRelationDesc, slot,
560 3880 : specToken, !specConflict);
561 :
562 : /*
563 : * Wake up anyone waiting for our decision. They will re-check
564 : * the tuple, see that it's no longer speculative, and wait on our
565 : * XID as if this was a regularly inserted tuple all along. Or if
566 : * we killed the tuple, they will see it's dead, and proceed as if
567 : * the tuple never existed.
568 : */
569 3880 : SpeculativeInsertionLockRelease(GetCurrentTransactionId());
570 :
571 : /*
572 : * If there was a conflict, start from the beginning. We'll do
573 : * the pre-check again, which will now find the conflicting tuple
574 : * (unless it aborts before we get there).
575 : */
576 3880 : if (specConflict)
577 : {
578 6 : list_free(recheckIndexes);
579 6 : goto vlock;
580 : }
581 :
582 : /* Since there was no insertion conflict, we're done */
583 : }
584 : else
585 : {
586 : /* insert the tuple normally */
587 11247594 : table_tuple_insert(resultRelationDesc, slot,
588 : estate->es_output_cid,
589 : 0, NULL);
590 :
591 : /* insert index entries for tuple */
592 11247572 : if (resultRelInfo->ri_NumIndices > 0)
593 4897996 : recheckIndexes = ExecInsertIndexTuples(slot, estate, false, NULL,
594 : NIL);
595 : }
596 : }
597 :
598 11251550 : if (canSetTag)
599 : {
600 11250834 : (estate->es_processed)++;
601 11250834 : setLastTid(&slot->tts_tid);
602 : }
603 :
604 : /*
605 : * If this insert is the result of a partition key update that moved the
606 : * tuple to a new partition, put this row into the transition NEW TABLE,
607 : * if there is one. We need to do this separately for DELETE and INSERT
608 : * because they happen on different tables.
609 : */
610 11251550 : ar_insert_trig_tcs = mtstate->mt_transition_capture;
611 11251550 : if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture
612 28 : && mtstate->mt_transition_capture->tcs_update_new_table)
613 : {
614 28 : ExecARUpdateTriggers(estate, resultRelInfo, NULL,
615 : NULL,
616 : slot,
617 : NULL,
618 28 : mtstate->mt_transition_capture);
619 :
620 : /*
621 : * We've already captured the NEW TABLE row, so make sure any AR
622 : * INSERT trigger fired below doesn't capture it again.
623 : */
624 28 : ar_insert_trig_tcs = NULL;
625 : }
626 :
627 : /* AFTER ROW INSERT Triggers */
628 11251550 : ExecARInsertTriggers(estate, resultRelInfo, slot, recheckIndexes,
629 : ar_insert_trig_tcs);
630 :
631 11251550 : list_free(recheckIndexes);
632 :
633 : /*
634 : * Check any WITH CHECK OPTION constraints from parent views. We are
635 : * required to do this after testing all constraints and uniqueness
636 : * violations per the SQL spec, so we do it after actually inserting the
637 : * record into the heap and all indexes.
638 : *
639 : * ExecWithCheckOptions will elog(ERROR) if a violation is found, so the
640 : * tuple will never be seen, if it violates the WITH CHECK OPTION.
641 : *
642 : * ExecWithCheckOptions() will skip any WCOs which are not of the kind we
643 : * are looking for at this point.
644 : */
645 11251550 : if (resultRelInfo->ri_WithCheckOptions != NIL)
646 204 : ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);
647 :
648 : /* Process RETURNING if present */
649 11251462 : if (resultRelInfo->ri_projectReturning)
650 1240 : result = ExecProcessReturning(resultRelInfo, slot, planSlot);
651 :
652 11251462 : return result;
653 : }
654 :
655 : /* ----------------------------------------------------------------
656 : * ExecDelete
657 : *
658 : * DELETE is like UPDATE, except that we delete the tuple and no
659 : * index modifications are needed.
660 : *
661 : * When deleting from a table, tupleid identifies the tuple to
662 : * delete and oldtuple is NULL. When deleting from a view,
663 : * oldtuple is passed to the INSTEAD OF triggers and identifies
664 : * what to delete, and tupleid is invalid. When deleting from a
665 : * foreign table, tupleid is invalid; the FDW has to figure out
666 : * which row to delete using data from the planSlot. oldtuple is
667 : * passed to foreign table triggers; it is NULL when the foreign
668 : * table has no relevant triggers. We use tupleDeleted to indicate
669 : * whether the tuple is actually deleted, callers can use it to
670 : * decide whether to continue the operation. When this DELETE is a
671 : * part of an UPDATE of partition-key, then the slot returned by
672 : * EvalPlanQual() is passed back using output parameter epqslot.
673 : *
674 : * Returns RETURNING result if any, otherwise NULL.
675 : * ----------------------------------------------------------------
676 : */
677 : static TupleTableSlot *
678 829866 : ExecDelete(ModifyTableState *mtstate,
679 : ItemPointer tupleid,
680 : HeapTuple oldtuple,
681 : TupleTableSlot *planSlot,
682 : EPQState *epqstate,
683 : EState *estate,
684 : bool processReturning,
685 : bool canSetTag,
686 : bool changingPart,
687 : bool *tupleDeleted,
688 : TupleTableSlot **epqreturnslot)
689 : {
690 : ResultRelInfo *resultRelInfo;
691 : Relation resultRelationDesc;
692 : TM_Result result;
693 : TM_FailureData tmfd;
694 829866 : TupleTableSlot *slot = NULL;
695 : TransitionCaptureState *ar_delete_trig_tcs;
696 :
697 829866 : if (tupleDeleted)
698 328 : *tupleDeleted = false;
699 :
700 : /*
701 : * get information on the (current) result relation
702 : */
703 829866 : resultRelInfo = estate->es_result_relation_info;
704 829866 : resultRelationDesc = resultRelInfo->ri_RelationDesc;
705 :
706 : /* BEFORE ROW DELETE Triggers */
707 834072 : if (resultRelInfo->ri_TrigDesc &&
708 4206 : resultRelInfo->ri_TrigDesc->trig_delete_before_row)
709 : {
710 : bool dodelete;
711 :
712 178 : dodelete = ExecBRDeleteTriggers(estate, epqstate, resultRelInfo,
713 : tupleid, oldtuple, epqreturnslot);
714 :
715 154 : if (!dodelete) /* "do nothing" */
716 20 : return NULL;
717 : }
718 :
719 : /* INSTEAD OF ROW DELETE Triggers */
720 833984 : if (resultRelInfo->ri_TrigDesc &&
721 4162 : resultRelInfo->ri_TrigDesc->trig_delete_instead_row)
722 34 : {
723 : bool dodelete;
724 :
725 : Assert(oldtuple != NULL);
726 38 : dodelete = ExecIRDeleteTriggers(estate, resultRelInfo, oldtuple);
727 :
728 38 : if (!dodelete) /* "do nothing" */
729 4 : return NULL;
730 : }
731 829784 : else if (resultRelInfo->ri_FdwRoutine)
732 : {
733 : /*
734 : * delete from foreign table: let the FDW do it
735 : *
736 : * We offer the returning slot as a place to store RETURNING data,
737 : * although the FDW can return some other slot if it wants.
738 : */
739 16 : slot = ExecGetReturningSlot(estate, resultRelInfo);
740 16 : slot = resultRelInfo->ri_FdwRoutine->ExecForeignDelete(estate,
741 : resultRelInfo,
742 : slot,
743 : planSlot);
744 :
745 16 : if (slot == NULL) /* "do nothing" */
746 0 : return NULL;
747 :
748 : /*
749 : * RETURNING expressions might reference the tableoid column, so
750 : * (re)initialize tts_tableOid before evaluating them.
751 : */
752 16 : if (TTS_EMPTY(slot))
753 0 : ExecStoreAllNullTuple(slot);
754 :
755 16 : slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
756 : }
757 : else
758 : {
759 : /*
760 : * delete the tuple
761 : *
762 : * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check
763 : * that the row to be deleted is visible to that snapshot, and throw a
764 : * can't-serialize error if not. This is a special-case behavior
765 : * needed for referential integrity updates in transaction-snapshot
766 : * mode transactions.
767 : */
768 : ldelete:;
769 829770 : result = table_tuple_delete(resultRelationDesc, tupleid,
770 : estate->es_output_cid,
771 : estate->es_snapshot,
772 : estate->es_crosscheck_snapshot,
773 : true /* wait for commit */ ,
774 : &tmfd,
775 : changingPart);
776 :
777 829734 : switch (result)
778 : {
779 : case TM_SelfModified:
780 :
781 : /*
782 : * The target tuple was already updated or deleted by the
783 : * current command, or by a later command in the current
784 : * transaction. The former case is possible in a join DELETE
785 : * where multiple tuples join to the same target tuple. This
786 : * is somewhat questionable, but Postgres has always allowed
787 : * it: we just ignore additional deletion attempts.
788 : *
789 : * The latter case arises if the tuple is modified by a
790 : * command in a BEFORE trigger, or perhaps by a command in a
791 : * volatile function used in the query. In such situations we
792 : * should not ignore the deletion, but it is equally unsafe to
793 : * proceed. We don't want to discard the original DELETE
794 : * while keeping the triggered actions based on its deletion;
795 : * and it would be no better to allow the original DELETE
796 : * while discarding updates that it triggered. The row update
797 : * carries some information that might be important according
798 : * to business rules; so throwing an error is the only safe
799 : * course.
800 : *
801 : * If a trigger actually intends this type of interaction, it
802 : * can re-execute the DELETE and then return NULL to cancel
803 : * the outer delete.
804 : */
805 20 : if (tmfd.cmax != estate->es_output_cid)
806 4 : ereport(ERROR,
807 : (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
808 : errmsg("tuple to be deleted was already modified by an operation triggered by the current command"),
809 : errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
810 :
811 : /* Else, already deleted by self; nothing to do */
812 16 : return NULL;
813 :
814 : case TM_Ok:
815 829694 : break;
816 :
817 : case TM_Updated:
818 : {
819 : TupleTableSlot *inputslot;
820 : TupleTableSlot *epqslot;
821 :
822 18 : if (IsolationUsesXactSnapshot())
823 0 : ereport(ERROR,
824 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
825 : errmsg("could not serialize access due to concurrent update")));
826 :
827 : /*
828 : * Already know that we're going to need to do EPQ, so
829 : * fetch tuple directly into the right slot.
830 : */
831 18 : EvalPlanQualBegin(epqstate, estate);
832 18 : inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc,
833 : resultRelInfo->ri_RangeTableIndex);
834 :
835 18 : result = table_tuple_lock(resultRelationDesc, tupleid,
836 : estate->es_snapshot,
837 : inputslot, estate->es_output_cid,
838 : LockTupleExclusive, LockWaitBlock,
839 : TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
840 : &tmfd);
841 :
842 16 : switch (result)
843 : {
844 : case TM_Ok:
845 : Assert(tmfd.traversed);
846 10 : epqslot = EvalPlanQual(estate,
847 : epqstate,
848 : resultRelationDesc,
849 : resultRelInfo->ri_RangeTableIndex,
850 : inputslot);
851 10 : if (TupIsNull(epqslot))
852 : /* Tuple not passing quals anymore, exiting... */
853 4 : return NULL;
854 :
855 : /*
856 : * If requested, skip delete and pass back the
857 : * updated row.
858 : */
859 6 : if (epqreturnslot)
860 : {
861 4 : *epqreturnslot = epqslot;
862 4 : return NULL;
863 : }
864 : else
865 2 : goto ldelete;
866 :
867 : case TM_SelfModified:
868 :
869 : /*
870 : * This can be reached when following an update
871 : * chain from a tuple updated by another session,
872 : * reaching a tuple that was already updated in
873 : * this transaction. If previously updated by this
874 : * command, ignore the delete, otherwise error
875 : * out.
876 : *
877 : * See also TM_SelfModified response to
878 : * table_tuple_delete() above.
879 : */
880 4 : if (tmfd.cmax != estate->es_output_cid)
881 2 : ereport(ERROR,
882 : (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
883 : errmsg("tuple to be deleted was already modified by an operation triggered by the current command"),
884 : errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
885 2 : return NULL;
886 :
887 : case TM_Deleted:
888 : /* tuple already deleted; nothing to do */
889 2 : return NULL;
890 :
891 : default:
892 :
893 : /*
894 : * TM_Invisible should be impossible because we're
895 : * waiting for updated row versions, and would
896 : * already have errored out if the first version
897 : * is invisible.
898 : *
899 : * TM_Updated should be impossible, because we're
900 : * locking the latest version via
901 : * TUPLE_LOCK_FLAG_FIND_LAST_VERSION.
902 : */
903 0 : elog(ERROR, "unexpected table_tuple_lock status: %u",
904 : result);
905 : return NULL;
906 : }
907 :
908 : Assert(false);
909 : break;
910 : }
911 :
912 : case TM_Deleted:
913 2 : if (IsolationUsesXactSnapshot())
914 0 : ereport(ERROR,
915 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
916 : errmsg("could not serialize access due to concurrent delete")));
917 : /* tuple already deleted; nothing to do */
918 2 : return NULL;
919 :
920 : default:
921 0 : elog(ERROR, "unrecognized table_tuple_delete status: %u",
922 : result);
923 : return NULL;
924 : }
925 :
926 : /*
927 : * Note: Normally one would think that we have to delete index tuples
928 : * associated with the heap tuple now...
929 : *
930 : * ... but in POSTGRES, we have no need to do this because VACUUM will
931 : * take care of it later. We can't delete index tuples immediately
932 : * anyway, since the tuple is still visible to other transactions.
933 : */
934 : }
935 :
936 829744 : if (canSetTag)
937 829310 : (estate->es_processed)++;
938 :
939 : /* Tell caller that the delete actually happened. */
940 829744 : if (tupleDeleted)
941 296 : *tupleDeleted = true;
942 :
943 : /*
944 : * If this delete is the result of a partition key update that moved the
945 : * tuple to a new partition, put this row into the transition OLD TABLE,
946 : * if there is one. We need to do this separately for DELETE and INSERT
947 : * because they happen on different tables.
948 : */
949 829744 : ar_delete_trig_tcs = mtstate->mt_transition_capture;
950 829744 : if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture
951 28 : && mtstate->mt_transition_capture->tcs_update_old_table)
952 : {
953 28 : ExecARUpdateTriggers(estate, resultRelInfo,
954 : tupleid,
955 : oldtuple,
956 : NULL,
957 : NULL,
958 28 : mtstate->mt_transition_capture);
959 :
960 : /*
961 : * We've already captured the NEW TABLE row, so make sure any AR
962 : * DELETE trigger fired below doesn't capture it again.
963 : */
964 28 : ar_delete_trig_tcs = NULL;
965 : }
966 :
967 : /* AFTER ROW DELETE Triggers */
968 829744 : ExecARDeleteTriggers(estate, resultRelInfo, tupleid, oldtuple,
969 : ar_delete_trig_tcs);
970 :
971 : /* Process RETURNING if present and if requested */
972 829744 : if (processReturning && resultRelInfo->ri_projectReturning)
973 : {
974 : /*
975 : * We have to put the target tuple into a slot, which means first we
976 : * gotta fetch it. We can use the trigger tuple slot.
977 : */
978 : TupleTableSlot *rslot;
979 :
980 594 : if (resultRelInfo->ri_FdwRoutine)
981 : {
982 : /* FDW must have provided a slot containing the deleted row */
983 : Assert(!TupIsNull(slot));
984 : }
985 : else
986 : {
987 592 : slot = ExecGetReturningSlot(estate, resultRelInfo);
988 592 : if (oldtuple != NULL)
989 : {
990 16 : ExecForceStoreHeapTuple(oldtuple, slot, false);
991 : }
992 : else
993 : {
994 576 : if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid,
995 : SnapshotAny, slot))
996 0 : elog(ERROR, "failed to fetch deleted tuple for DELETE RETURNING");
997 : }
998 : }
999 :
1000 594 : rslot = ExecProcessReturning(resultRelInfo, slot, planSlot);
1001 :
1002 : /*
1003 : * Before releasing the target tuple again, make sure rslot has a
1004 : * local copy of any pass-by-reference values.
1005 : */
1006 594 : ExecMaterializeSlot(rslot);
1007 :
1008 594 : ExecClearTuple(slot);
1009 :
1010 594 : return rslot;
1011 : }
1012 :
1013 829150 : return NULL;
1014 : }
1015 :
1016 : /* ----------------------------------------------------------------
1017 : * ExecUpdate
1018 : *
1019 : * note: we can't run UPDATE queries with transactions
1020 : * off because UPDATEs are actually INSERTs and our
1021 : * scan will mistakenly loop forever, updating the tuple
1022 : * it just inserted.. This should be fixed but until it
1023 : * is, we don't want to get stuck in an infinite loop
1024 : * which corrupts your database..
1025 : *
1026 : * When updating a table, tupleid identifies the tuple to
1027 : * update and oldtuple is NULL. When updating a view, oldtuple
1028 : * is passed to the INSTEAD OF triggers and identifies what to
1029 : * update, and tupleid is invalid. When updating a foreign table,
1030 : * tupleid is invalid; the FDW has to figure out which row to
1031 : * update using data from the planSlot. oldtuple is passed to
1032 : * foreign table triggers; it is NULL when the foreign table has
1033 : * no relevant triggers.
1034 : *
1035 : * Returns RETURNING result if any, otherwise NULL.
1036 : * ----------------------------------------------------------------
1037 : */
1038 : static TupleTableSlot *
1039 118366 : ExecUpdate(ModifyTableState *mtstate,
1040 : ItemPointer tupleid,
1041 : HeapTuple oldtuple,
1042 : TupleTableSlot *slot,
1043 : TupleTableSlot *planSlot,
1044 : EPQState *epqstate,
1045 : EState *estate,
1046 : bool canSetTag)
1047 : {
1048 : ResultRelInfo *resultRelInfo;
1049 : Relation resultRelationDesc;
1050 : TM_Result result;
1051 : TM_FailureData tmfd;
1052 118366 : List *recheckIndexes = NIL;
1053 118366 : TupleConversionMap *saved_tcs_map = NULL;
1054 :
1055 : /*
1056 : * abort the operation if not running transactions
1057 : */
1058 118366 : if (IsBootstrapProcessingMode())
1059 0 : elog(ERROR, "cannot UPDATE during bootstrap");
1060 :
1061 118366 : ExecMaterializeSlot(slot);
1062 :
1063 : /*
1064 : * get information on the (current) result relation
1065 : */
1066 118366 : resultRelInfo = estate->es_result_relation_info;
1067 118366 : resultRelationDesc = resultRelInfo->ri_RelationDesc;
1068 :
1069 : /* BEFORE ROW UPDATE Triggers */
1070 122162 : if (resultRelInfo->ri_TrigDesc &&
1071 3796 : resultRelInfo->ri_TrigDesc->trig_update_before_row)
1072 : {
1073 1820 : if (!ExecBRUpdateTriggers(estate, epqstate, resultRelInfo,
1074 : tupleid, oldtuple, slot))
1075 88 : return NULL; /* "do nothing" */
1076 : }
1077 :
1078 : /* INSTEAD OF ROW UPDATE Triggers */
1079 121930 : if (resultRelInfo->ri_TrigDesc &&
1080 3680 : resultRelInfo->ri_TrigDesc->trig_update_instead_row)
1081 : {
1082 140 : if (!ExecIRUpdateTriggers(estate, resultRelInfo,
1083 : oldtuple, slot))
1084 12 : return NULL; /* "do nothing" */
1085 : }
1086 118172 : else if (resultRelInfo->ri_FdwRoutine)
1087 : {
1088 : /*
1089 : * Compute stored generated columns
1090 : */
1091 138 : if (resultRelationDesc->rd_att->constr &&
1092 56 : resultRelationDesc->rd_att->constr->has_generated_stored)
1093 2 : ExecComputeStoredGenerated(estate, slot);
1094 :
1095 : /*
1096 : * update in foreign table: let the FDW do it
1097 : */
1098 82 : slot = resultRelInfo->ri_FdwRoutine->ExecForeignUpdate(estate,
1099 : resultRelInfo,
1100 : slot,
1101 : planSlot);
1102 :
1103 82 : if (slot == NULL) /* "do nothing" */
1104 2 : return NULL;
1105 :
1106 : /*
1107 : * AFTER ROW Triggers or RETURNING expressions might reference the
1108 : * tableoid column, so (re-)initialize tts_tableOid before evaluating
1109 : * them.
1110 : */
1111 80 : slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
1112 : }
1113 : else
1114 : {
1115 : LockTupleMode lockmode;
1116 : bool partition_constraint_failed;
1117 : bool update_indexes;
1118 :
1119 : /*
1120 : * Constraints might reference the tableoid column, so (re-)initialize
1121 : * tts_tableOid before evaluating them.
1122 : */
1123 118090 : slot->tts_tableOid = RelationGetRelid(resultRelationDesc);
1124 :
1125 : /*
1126 : * Compute stored generated columns
1127 : */
1128 179648 : if (resultRelationDesc->rd_att->constr &&
1129 61558 : resultRelationDesc->rd_att->constr->has_generated_stored)
1130 44 : ExecComputeStoredGenerated(estate, slot);
1131 :
1132 : /*
1133 : * Check any RLS UPDATE WITH CHECK policies
1134 : *
1135 : * If we generate a new candidate tuple after EvalPlanQual testing, we
1136 : * must loop back here and recheck any RLS policies and constraints.
1137 : * (We don't need to redo triggers, however. If there are any BEFORE
1138 : * triggers then trigger.c will have done table_tuple_lock to lock the
1139 : * correct tuple, so there's no need to do them again.)
1140 : */
1141 : lreplace:;
1142 :
1143 : /* ensure slot is independent, consider e.g. EPQ */
1144 118158 : ExecMaterializeSlot(slot);
1145 :
1146 : /*
1147 : * If partition constraint fails, this row might get moved to another
1148 : * partition, in which case we should check the RLS CHECK policy just
1149 : * before inserting into the new partition, rather than doing it here.
1150 : * This is because a trigger on that partition might again change the
1151 : * row. So skip the WCO checks if the partition constraint fails.
1152 : */
1153 118158 : partition_constraint_failed =
1154 118952 : resultRelInfo->ri_PartitionCheck &&
1155 794 : !ExecPartitionCheck(resultRelInfo, slot, estate, false);
1156 :
1157 235960 : if (!partition_constraint_failed &&
1158 117802 : resultRelInfo->ri_WithCheckOptions != NIL)
1159 : {
1160 : /*
1161 : * ExecWithCheckOptions() will skip any WCOs which are not of the
1162 : * kind we are looking for at this point.
1163 : */
1164 284 : ExecWithCheckOptions(WCO_RLS_UPDATE_CHECK,
1165 : resultRelInfo, slot, estate);
1166 : }
1167 :
1168 : /*
1169 : * If a partition check failed, try to move the row into the right
1170 : * partition.
1171 : */
1172 118130 : if (partition_constraint_failed)
1173 : {
1174 : bool tuple_deleted;
1175 : TupleTableSlot *ret_slot;
1176 356 : TupleTableSlot *epqslot = NULL;
1177 356 : PartitionTupleRouting *proute = mtstate->mt_partition_tuple_routing;
1178 : int map_index;
1179 : TupleConversionMap *tupconv_map;
1180 :
1181 : /*
1182 : * Disallow an INSERT ON CONFLICT DO UPDATE that causes the
1183 : * original row to migrate to a different partition. Maybe this
1184 : * can be implemented some day, but it seems a fringe feature with
1185 : * little redeeming value.
1186 : */
1187 356 : if (((ModifyTable *) mtstate->ps.plan)->onConflictAction == ONCONFLICT_UPDATE)
1188 0 : ereport(ERROR,
1189 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1190 : errmsg("invalid ON UPDATE specification"),
1191 : errdetail("The result tuple would appear in a different partition than the original tuple.")));
1192 :
1193 : /*
1194 : * When an UPDATE is run on a leaf partition, we will not have
1195 : * partition tuple routing set up. In that case, fail with
1196 : * partition constraint violation error.
1197 : */
1198 356 : if (proute == NULL)
1199 28 : ExecPartitionCheckEmitError(resultRelInfo, slot, estate);
1200 :
1201 : /*
1202 : * Row movement, part 1. Delete the tuple, but skip RETURNING
1203 : * processing. We want to return rows from INSERT.
1204 : */
1205 328 : ExecDelete(mtstate, tupleid, oldtuple, planSlot, epqstate,
1206 : estate, false, false /* canSetTag */ ,
1207 : true /* changingPart */ , &tuple_deleted, &epqslot);
1208 :
1209 : /*
1210 : * For some reason if DELETE didn't happen (e.g. trigger prevented
1211 : * it, or it was already deleted by self, or it was concurrently
1212 : * deleted by another transaction), then we should skip the insert
1213 : * as well; otherwise, an UPDATE could cause an increase in the
1214 : * total number of rows across all partitions, which is clearly
1215 : * wrong.
1216 : *
1217 : * For a normal UPDATE, the case where the tuple has been the
1218 : * subject of a concurrent UPDATE or DELETE would be handled by
1219 : * the EvalPlanQual machinery, but for an UPDATE that we've
1220 : * translated into a DELETE from this partition and an INSERT into
1221 : * some other partition, that's not available, because CTID chains
1222 : * can't span relation boundaries. We mimic the semantics to a
1223 : * limited extent by skipping the INSERT if the DELETE fails to
1224 : * find a tuple. This ensures that two concurrent attempts to
1225 : * UPDATE the same tuple at the same time can't turn one tuple
1226 : * into two, and that an UPDATE of a just-deleted tuple can't
1227 : * resurrect it.
1228 : */
1229 328 : if (!tuple_deleted)
1230 : {
1231 : /*
1232 : * epqslot will be typically NULL. But when ExecDelete()
1233 : * finds that another transaction has concurrently updated the
1234 : * same row, it re-fetches the row, skips the delete, and
1235 : * epqslot is set to the re-fetched tuple slot. In that case,
1236 : * we need to do all the checks again.
1237 : */
1238 32 : if (TupIsNull(epqslot))
1239 318 : return NULL;
1240 : else
1241 : {
1242 6 : slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
1243 6 : goto lreplace;
1244 : }
1245 : }
1246 :
1247 : /*
1248 : * Updates set the transition capture map only when a new subplan
1249 : * is chosen. But for inserts, it is set for each row. So after
1250 : * INSERT, we need to revert back to the map created for UPDATE;
1251 : * otherwise the next UPDATE will incorrectly use the one created
1252 : * for INSERT. So first save the one created for UPDATE.
1253 : */
1254 296 : if (mtstate->mt_transition_capture)
1255 28 : saved_tcs_map = mtstate->mt_transition_capture->tcs_map;
1256 :
1257 : /*
1258 : * resultRelInfo is one of the per-subplan resultRelInfos. So we
1259 : * should convert the tuple into root's tuple descriptor, since
1260 : * ExecInsert() starts the search from root. The tuple conversion
1261 : * map list is in the order of mtstate->resultRelInfo[], so to
1262 : * retrieve the one for this resultRel, we need to know the
1263 : * position of the resultRel in mtstate->resultRelInfo[].
1264 : */
1265 296 : map_index = resultRelInfo - mtstate->resultRelInfo;
1266 : Assert(map_index >= 0 && map_index < mtstate->mt_nplans);
1267 296 : tupconv_map = tupconv_map_for_subplan(mtstate, map_index);
1268 296 : if (tupconv_map != NULL)
1269 108 : slot = execute_attr_map_slot(tupconv_map->attrMap,
1270 : slot,
1271 : mtstate->mt_root_tuple_slot);
1272 :
1273 : /*
1274 : * Prepare for tuple routing, making it look like we're inserting
1275 : * into the root.
1276 : */
1277 : Assert(mtstate->rootResultRelInfo != NULL);
1278 296 : slot = ExecPrepareTupleRouting(mtstate, estate, proute,
1279 : mtstate->rootResultRelInfo, slot);
1280 :
1281 286 : ret_slot = ExecInsert(mtstate, slot, planSlot,
1282 : estate, canSetTag);
1283 :
1284 : /* Revert ExecPrepareTupleRouting's node change. */
1285 266 : estate->es_result_relation_info = resultRelInfo;
1286 266 : if (mtstate->mt_transition_capture)
1287 : {
1288 28 : mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
1289 28 : mtstate->mt_transition_capture->tcs_map = saved_tcs_map;
1290 : }
1291 :
1292 266 : return ret_slot;
1293 : }
1294 :
1295 : /*
1296 : * Check the constraints of the tuple. We've already checked the
1297 : * partition constraint above; however, we must still ensure the tuple
1298 : * passes all other constraints, so we will call ExecConstraints() and
1299 : * have it validate all remaining checks.
1300 : */
1301 117774 : if (resultRelationDesc->rd_att->constr)
1302 61524 : ExecConstraints(resultRelInfo, slot, estate);
1303 :
1304 : /*
1305 : * replace the heap tuple
1306 : *
1307 : * Note: if es_crosscheck_snapshot isn't InvalidSnapshot, we check
1308 : * that the row to be updated is visible to that snapshot, and throw a
1309 : * can't-serialize error if not. This is a special-case behavior
1310 : * needed for referential integrity updates in transaction-snapshot
1311 : * mode transactions.
1312 : */
1313 117758 : result = table_tuple_update(resultRelationDesc, tupleid, slot,
1314 : estate->es_output_cid,
1315 : estate->es_snapshot,
1316 : estate->es_crosscheck_snapshot,
1317 : true /* wait for commit */ ,
1318 : &tmfd, &lockmode, &update_indexes);
1319 :
1320 117734 : switch (result)
1321 : {
1322 : case TM_SelfModified:
1323 :
1324 : /*
1325 : * The target tuple was already updated or deleted by the
1326 : * current command, or by a later command in the current
1327 : * transaction. The former case is possible in a join UPDATE
1328 : * where multiple tuples join to the same target tuple. This
1329 : * is pretty questionable, but Postgres has always allowed it:
1330 : * we just execute the first update action and ignore
1331 : * additional update attempts.
1332 : *
1333 : * The latter case arises if the tuple is modified by a
1334 : * command in a BEFORE trigger, or perhaps by a command in a
1335 : * volatile function used in the query. In such situations we
1336 : * should not ignore the update, but it is equally unsafe to
1337 : * proceed. We don't want to discard the original UPDATE
1338 : * while keeping the triggered actions based on it; and we
1339 : * have no principled way to merge this update with the
1340 : * previous ones. So throwing an error is the only safe
1341 : * course.
1342 : *
1343 : * If a trigger actually intends this type of interaction, it
1344 : * can re-execute the UPDATE (assuming it can figure out how)
1345 : * and then return NULL to cancel the outer update.
1346 : */
1347 56 : if (tmfd.cmax != estate->es_output_cid)
1348 4 : ereport(ERROR,
1349 : (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
1350 : errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
1351 : errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
1352 :
1353 : /* Else, already updated by self; nothing to do */
1354 52 : return NULL;
1355 :
1356 : case TM_Ok:
1357 117600 : break;
1358 :
1359 : case TM_Updated:
1360 : {
1361 : TupleTableSlot *inputslot;
1362 : TupleTableSlot *epqslot;
1363 :
1364 76 : if (IsolationUsesXactSnapshot())
1365 0 : ereport(ERROR,
1366 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1367 : errmsg("could not serialize access due to concurrent update")));
1368 :
1369 : /*
1370 : * Already know that we're going to need to do EPQ, so
1371 : * fetch tuple directly into the right slot.
1372 : */
1373 76 : EvalPlanQualBegin(epqstate, estate);
1374 76 : inputslot = EvalPlanQualSlot(epqstate, resultRelationDesc,
1375 : resultRelInfo->ri_RangeTableIndex);
1376 :
1377 76 : result = table_tuple_lock(resultRelationDesc, tupleid,
1378 : estate->es_snapshot,
1379 : inputslot, estate->es_output_cid,
1380 : lockmode, LockWaitBlock,
1381 : TUPLE_LOCK_FLAG_FIND_LAST_VERSION,
1382 : &tmfd);
1383 :
1384 72 : switch (result)
1385 : {
1386 : case TM_Ok:
1387 : Assert(tmfd.traversed);
1388 :
1389 64 : epqslot = EvalPlanQual(estate,
1390 : epqstate,
1391 : resultRelationDesc,
1392 : resultRelInfo->ri_RangeTableIndex,
1393 : inputslot);
1394 64 : if (TupIsNull(epqslot))
1395 : /* Tuple not passing quals anymore, exiting... */
1396 2 : return NULL;
1397 :
1398 62 : slot = ExecFilterJunk(resultRelInfo->ri_junkFilter, epqslot);
1399 62 : goto lreplace;
1400 :
1401 : case TM_Deleted:
1402 : /* tuple already deleted; nothing to do */
1403 2 : return NULL;
1404 :
1405 : case TM_SelfModified:
1406 :
1407 : /*
1408 : * This can be reached when following an update
1409 : * chain from a tuple updated by another session,
1410 : * reaching a tuple that was already updated in
1411 : * this transaction. If previously modified by
1412 : * this command, ignore the redundant update,
1413 : * otherwise error out.
1414 : *
1415 : * See also TM_SelfModified response to
1416 : * table_tuple_update() above.
1417 : */
1418 6 : if (tmfd.cmax != estate->es_output_cid)
1419 2 : ereport(ERROR,
1420 : (errcode(ERRCODE_TRIGGERED_DATA_CHANGE_VIOLATION),
1421 : errmsg("tuple to be updated was already modified by an operation triggered by the current command"),
1422 : errhint("Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows.")));
1423 4 : return NULL;
1424 :
1425 : default:
1426 : /* see table_tuple_lock call in ExecDelete() */
1427 0 : elog(ERROR, "unexpected table_tuple_lock status: %u",
1428 : result);
1429 : return NULL;
1430 : }
1431 : }
1432 :
1433 : break;
1434 :
1435 : case TM_Deleted:
1436 2 : if (IsolationUsesXactSnapshot())
1437 0 : ereport(ERROR,
1438 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1439 : errmsg("could not serialize access due to concurrent delete")));
1440 : /* tuple already deleted; nothing to do */
1441 2 : return NULL;
1442 :
1443 : default:
1444 0 : elog(ERROR, "unrecognized table_tuple_update status: %u",
1445 : result);
1446 : return NULL;
1447 : }
1448 :
1449 : /* insert index entries for tuple if necessary */
1450 117600 : if (resultRelInfo->ri_NumIndices > 0 && update_indexes)
1451 60402 : recheckIndexes = ExecInsertIndexTuples(slot, estate, false, NULL, NIL);
1452 : }
1453 :
1454 117730 : if (canSetTag)
1455 117334 : (estate->es_processed)++;
1456 :
1457 : /* AFTER ROW UPDATE Triggers */
1458 117730 : ExecARUpdateTriggers(estate, resultRelInfo, tupleid, oldtuple, slot,
1459 : recheckIndexes,
1460 117730 : mtstate->operation == CMD_INSERT ?
1461 : mtstate->mt_oc_transition_capture :
1462 : mtstate->mt_transition_capture);
1463 :
1464 117730 : list_free(recheckIndexes);
1465 :
1466 : /*
1467 : * Check any WITH CHECK OPTION constraints from parent views. We are
1468 : * required to do this after testing all constraints and uniqueness
1469 : * violations per the SQL spec, so we do it after actually updating the
1470 : * record in the heap and all indexes.
1471 : *
1472 : * ExecWithCheckOptions() will skip any WCOs which are not of the kind we
1473 : * are looking for at this point.
1474 : */
1475 117730 : if (resultRelInfo->ri_WithCheckOptions != NIL)
1476 272 : ExecWithCheckOptions(WCO_VIEW_CHECK, resultRelInfo, slot, estate);
1477 :
1478 : /* Process RETURNING if present */
1479 117686 : if (resultRelInfo->ri_projectReturning)
1480 1508 : return ExecProcessReturning(resultRelInfo, slot, planSlot);
1481 :
1482 116178 : return NULL;
1483 : }
1484 :
1485 : /*
1486 : * ExecOnConflictUpdate --- execute UPDATE of INSERT ON CONFLICT DO UPDATE
1487 : *
1488 : * Try to lock tuple for update as part of speculative insertion. If
1489 : * a qual originating from ON CONFLICT DO UPDATE is satisfied, update
1490 : * (but still lock row, even though it may not satisfy estate's
1491 : * snapshot).
1492 : *
1493 : * Returns true if we're done (with or without an update), or false if
1494 : * the caller must retry the INSERT from scratch.
1495 : */
1496 : static bool
1497 4928 : ExecOnConflictUpdate(ModifyTableState *mtstate,
1498 : ResultRelInfo *resultRelInfo,
1499 : ItemPointer conflictTid,
1500 : TupleTableSlot *planSlot,
1501 : TupleTableSlot *excludedSlot,
1502 : EState *estate,
1503 : bool canSetTag,
1504 : TupleTableSlot **returning)
1505 : {
1506 4928 : ExprContext *econtext = mtstate->ps.ps_ExprContext;
1507 4928 : Relation relation = resultRelInfo->ri_RelationDesc;
1508 4928 : ExprState *onConflictSetWhere = resultRelInfo->ri_onConflict->oc_WhereClause;
1509 4928 : TupleTableSlot *existing = resultRelInfo->ri_onConflict->oc_Existing;
1510 : TM_FailureData tmfd;
1511 : LockTupleMode lockmode;
1512 : TM_Result test;
1513 : Datum xminDatum;
1514 : TransactionId xmin;
1515 : bool isnull;
1516 :
1517 : /* Determine lock mode to use */
1518 4928 : lockmode = ExecUpdateLockMode(estate, resultRelInfo);
1519 :
1520 : /*
1521 : * Lock tuple for update. Don't follow updates when tuple cannot be
1522 : * locked without doing so. A row locking conflict here means our
1523 : * previous conclusion that the tuple is conclusively committed is not
1524 : * true anymore.
1525 : */
1526 4928 : test = table_tuple_lock(relation, conflictTid,
1527 : estate->es_snapshot,
1528 : existing, estate->es_output_cid,
1529 : lockmode, LockWaitBlock, 0,
1530 : &tmfd);
1531 4928 : switch (test)
1532 : {
1533 : case TM_Ok:
1534 : /* success! */
1535 4912 : break;
1536 :
1537 : case TM_Invisible:
1538 :
1539 : /*
1540 : * This can occur when a just inserted tuple is updated again in
1541 : * the same command. E.g. because multiple rows with the same
1542 : * conflicting key values are inserted.
1543 : *
1544 : * This is somewhat similar to the ExecUpdate() TM_SelfModified
1545 : * case. We do not want to proceed because it would lead to the
1546 : * same row being updated a second time in some unspecified order,
1547 : * and in contrast to plain UPDATEs there's no historical behavior
1548 : * to break.
1549 : *
1550 : * It is the user's responsibility to prevent this situation from
1551 : * occurring. These problems are why SQL-2003 similarly specifies
1552 : * that for SQL MERGE, an exception must be raised in the event of
1553 : * an attempt to update the same row twice.
1554 : */
1555 16 : xminDatum = slot_getsysattr(existing,
1556 : MinTransactionIdAttributeNumber,
1557 : &isnull);
1558 : Assert(!isnull);
1559 16 : xmin = DatumGetTransactionId(xminDatum);
1560 :
1561 16 : if (TransactionIdIsCurrentTransactionId(xmin))
1562 16 : ereport(ERROR,
1563 : (errcode(ERRCODE_CARDINALITY_VIOLATION),
1564 : errmsg("ON CONFLICT DO UPDATE command cannot affect row a second time"),
1565 : errhint("Ensure that no rows proposed for insertion within the same command have duplicate constrained values.")));
1566 :
1567 : /* This shouldn't happen */
1568 0 : elog(ERROR, "attempted to lock invisible tuple");
1569 : break;
1570 :
1571 : case TM_SelfModified:
1572 :
1573 : /*
1574 : * This state should never be reached. As a dirty snapshot is used
1575 : * to find conflicting tuples, speculative insertion wouldn't have
1576 : * seen this row to conflict with.
1577 : */
1578 0 : elog(ERROR, "unexpected self-updated tuple");
1579 : break;
1580 :
1581 : case TM_Updated:
1582 0 : if (IsolationUsesXactSnapshot())
1583 0 : ereport(ERROR,
1584 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1585 : errmsg("could not serialize access due to concurrent update")));
1586 :
1587 : /*
1588 : * As long as we don't support an UPDATE of INSERT ON CONFLICT for
1589 : * a partitioned table we shouldn't reach to a case where tuple to
1590 : * be lock is moved to another partition due to concurrent update
1591 : * of the partition key.
1592 : */
1593 : Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid));
1594 :
1595 : /*
1596 : * Tell caller to try again from the very start.
1597 : *
1598 : * It does not make sense to use the usual EvalPlanQual() style
1599 : * loop here, as the new version of the row might not conflict
1600 : * anymore, or the conflicting tuple has actually been deleted.
1601 : */
1602 0 : ExecClearTuple(existing);
1603 0 : return false;
1604 :
1605 : case TM_Deleted:
1606 0 : if (IsolationUsesXactSnapshot())
1607 0 : ereport(ERROR,
1608 : (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
1609 : errmsg("could not serialize access due to concurrent delete")));
1610 :
1611 : /* see TM_Updated case */
1612 : Assert(!ItemPointerIndicatesMovedPartitions(&tmfd.ctid));
1613 0 : ExecClearTuple(existing);
1614 0 : return false;
1615 :
1616 : default:
1617 0 : elog(ERROR, "unrecognized table_tuple_lock status: %u", test);
1618 : }
1619 :
1620 : /* Success, the tuple is locked. */
1621 :
1622 : /*
1623 : * Verify that the tuple is visible to our MVCC snapshot if the current
1624 : * isolation level mandates that.
1625 : *
1626 : * It's not sufficient to rely on the check within ExecUpdate() as e.g.
1627 : * CONFLICT ... WHERE clause may prevent us from reaching that.
1628 : *
1629 : * This means we only ever continue when a new command in the current
1630 : * transaction could see the row, even though in READ COMMITTED mode the
1631 : * tuple will not be visible according to the current statement's
1632 : * snapshot. This is in line with the way UPDATE deals with newer tuple
1633 : * versions.
1634 : */
1635 4912 : ExecCheckTupleVisible(estate, relation, existing);
1636 :
1637 : /*
1638 : * Make tuple and any needed join variables available to ExecQual and
1639 : * ExecProject. The EXCLUDED tuple is installed in ecxt_innertuple, while
1640 : * the target's existing tuple is installed in the scantuple. EXCLUDED
1641 : * has been made to reference INNER_VAR in setrefs.c, but there is no
1642 : * other redirection.
1643 : */
1644 4912 : econtext->ecxt_scantuple = existing;
1645 4912 : econtext->ecxt_innertuple = excludedSlot;
1646 4912 : econtext->ecxt_outertuple = NULL;
1647 :
1648 4912 : if (!ExecQual(onConflictSetWhere, econtext))
1649 : {
1650 22 : ExecClearTuple(existing); /* see return below */
1651 22 : InstrCountFiltered1(&mtstate->ps, 1);
1652 22 : return true; /* done with the tuple */
1653 : }
1654 :
1655 4890 : if (resultRelInfo->ri_WithCheckOptions != NIL)
1656 : {
1657 : /*
1658 : * Check target's existing tuple against UPDATE-applicable USING
1659 : * security barrier quals (if any), enforced here as RLS checks/WCOs.
1660 : *
1661 : * The rewriter creates UPDATE RLS checks/WCOs for UPDATE security
1662 : * quals, and stores them as WCOs of "kind" WCO_RLS_CONFLICT_CHECK,
1663 : * but that's almost the extent of its special handling for ON
1664 : * CONFLICT DO UPDATE.
1665 : *
1666 : * The rewriter will also have associated UPDATE applicable straight
1667 : * RLS checks/WCOs for the benefit of the ExecUpdate() call that
1668 : * follows. INSERTs and UPDATEs naturally have mutually exclusive WCO
1669 : * kinds, so there is no danger of spurious over-enforcement in the
1670 : * INSERT or UPDATE path.
1671 : */
1672 40 : ExecWithCheckOptions(WCO_RLS_CONFLICT_CHECK, resultRelInfo,
1673 : existing,
1674 : mtstate->ps.state);
1675 : }
1676 :
1677 : /* Project the new tuple version */
1678 4874 : ExecProject(resultRelInfo->ri_onConflict->oc_ProjInfo);
1679 :
1680 : /*
1681 : * Note that it is possible that the target tuple has been modified in
1682 : * this session, after the above table_tuple_lock. We choose to not error
1683 : * out in that case, in line with ExecUpdate's treatment of similar cases.
1684 : * This can happen if an UPDATE is triggered from within ExecQual(),
1685 : * ExecWithCheckOptions() or ExecProject() above, e.g. by selecting from a
1686 : * wCTE in the ON CONFLICT's SET.
1687 : */
1688 :
1689 : /* Execute UPDATE with projection */
1690 9748 : *returning = ExecUpdate(mtstate, conflictTid, NULL,
1691 4874 : resultRelInfo->ri_onConflict->oc_ProjSlot,
1692 : planSlot,
1693 : &mtstate->mt_epqstate, mtstate->ps.state,
1694 : canSetTag);
1695 :
1696 : /*
1697 : * Clear out existing tuple, as there might not be another conflict among
1698 : * the next input rows. Don't want to hold resources till the end of the
1699 : * query.
1700 : */
1701 4854 : ExecClearTuple(existing);
1702 4854 : return true;
1703 : }
1704 :
1705 :
1706 : /*
1707 : * Process BEFORE EACH STATEMENT triggers
1708 : */
1709 : static void
1710 76196 : fireBSTriggers(ModifyTableState *node)
1711 : {
1712 76196 : ModifyTable *plan = (ModifyTable *) node->ps.plan;
1713 76196 : ResultRelInfo *resultRelInfo = node->resultRelInfo;
1714 :
1715 : /*
1716 : * If the node modifies a partitioned table, we must fire its triggers.
1717 : * Note that in that case, node->resultRelInfo points to the first leaf
1718 : * partition, not the root table.
1719 : */
1720 76196 : if (node->rootResultRelInfo != NULL)
1721 2006 : resultRelInfo = node->rootResultRelInfo;
1722 :
1723 76196 : switch (node->operation)
1724 : {
1725 : case CMD_INSERT:
1726 64230 : ExecBSInsertTriggers(node->ps.state, resultRelInfo);
1727 64222 : if (plan->onConflictAction == ONCONFLICT_UPDATE)
1728 528 : ExecBSUpdateTriggers(node->ps.state,
1729 : resultRelInfo);
1730 64222 : break;
1731 : case CMD_UPDATE:
1732 9312 : ExecBSUpdateTriggers(node->ps.state, resultRelInfo);
1733 9312 : break;
1734 : case CMD_DELETE:
1735 2654 : ExecBSDeleteTriggers(node->ps.state, resultRelInfo);
1736 2654 : break;
1737 : default:
1738 0 : elog(ERROR, "unknown operation");
1739 : break;
1740 : }
1741 76188 : }
1742 :
1743 : /*
1744 : * Return the target rel ResultRelInfo.
1745 : *
1746 : * This relation is the same as :
1747 : * - the relation for which we will fire AFTER STATEMENT triggers.
1748 : * - the relation into whose tuple format all captured transition tuples must
1749 : * be converted.
1750 : * - the root partitioned table.
1751 : */
1752 : static ResultRelInfo *
1753 228056 : getTargetResultRelInfo(ModifyTableState *node)
1754 : {
1755 : /*
1756 : * Note that if the node modifies a partitioned table, node->resultRelInfo
1757 : * points to the first leaf partition, not the root table.
1758 : */
1759 228056 : if (node->rootResultRelInfo != NULL)
1760 6322 : return node->rootResultRelInfo;
1761 : else
1762 221734 : return node->resultRelInfo;
1763 : }
1764 :
1765 : /*
1766 : * Process AFTER EACH STATEMENT triggers
1767 : */
1768 : static void
1769 74474 : fireASTriggers(ModifyTableState *node)
1770 : {
1771 74474 : ModifyTable *plan = (ModifyTable *) node->ps.plan;
1772 74474 : ResultRelInfo *resultRelInfo = getTargetResultRelInfo(node);
1773 :
1774 74474 : switch (node->operation)
1775 : {
1776 : case CMD_INSERT:
1777 62888 : if (plan->onConflictAction == ONCONFLICT_UPDATE)
1778 460 : ExecASUpdateTriggers(node->ps.state,
1779 : resultRelInfo,
1780 460 : node->mt_oc_transition_capture);
1781 62888 : ExecASInsertTriggers(node->ps.state, resultRelInfo,
1782 62888 : node->mt_transition_capture);
1783 62888 : break;
1784 : case CMD_UPDATE:
1785 9028 : ExecASUpdateTriggers(node->ps.state, resultRelInfo,
1786 9028 : node->mt_transition_capture);
1787 9028 : break;
1788 : case CMD_DELETE:
1789 2558 : ExecASDeleteTriggers(node->ps.state, resultRelInfo,
1790 2558 : node->mt_transition_capture);
1791 2558 : break;
1792 : default:
1793 0 : elog(ERROR, "unknown operation");
1794 : break;
1795 : }
1796 74474 : }
1797 :
1798 : /*
1799 : * Set up the state needed for collecting transition tuples for AFTER
1800 : * triggers.
1801 : */
1802 : static void
1803 76228 : ExecSetupTransitionCaptureState(ModifyTableState *mtstate, EState *estate)
1804 : {
1805 76228 : ModifyTable *plan = (ModifyTable *) mtstate->ps.plan;
1806 76228 : ResultRelInfo *targetRelInfo = getTargetResultRelInfo(mtstate);
1807 :
1808 : /* Check for transition tables on the directly targeted relation. */
1809 76228 : mtstate->mt_transition_capture =
1810 152456 : MakeTransitionCaptureState(targetRelInfo->ri_TrigDesc,
1811 76228 : RelationGetRelid(targetRelInfo->ri_RelationDesc),
1812 : mtstate->operation);
1813 140458 : if (plan->operation == CMD_INSERT &&
1814 64230 : plan->onConflictAction == ONCONFLICT_UPDATE)
1815 528 : mtstate->mt_oc_transition_capture =
1816 528 : MakeTransitionCaptureState(targetRelInfo->ri_TrigDesc,
1817 528 : RelationGetRelid(targetRelInfo->ri_RelationDesc),
1818 : CMD_UPDATE);
1819 :
1820 : /*
1821 : * If we found that we need to collect transition tuples then we may also
1822 : * need tuple conversion maps for any children that have TupleDescs that
1823 : * aren't compatible with the tuplestores. (We can share these maps
1824 : * between the regular and ON CONFLICT cases.)
1825 : */
1826 152178 : if (mtstate->mt_transition_capture != NULL ||
1827 75950 : mtstate->mt_oc_transition_capture != NULL)
1828 : {
1829 282 : ExecSetupChildParentMapForSubplan(mtstate);
1830 :
1831 : /*
1832 : * Install the conversion map for the first plan for UPDATE and DELETE
1833 : * operations. It will be advanced each time we switch to the next
1834 : * plan. (INSERT operations set it every time, so we need not update
1835 : * mtstate->mt_oc_transition_capture here.)
1836 : */
1837 282 : if (mtstate->mt_transition_capture && mtstate->operation != CMD_INSERT)
1838 332 : mtstate->mt_transition_capture->tcs_map =
1839 166 : tupconv_map_for_subplan(mtstate, 0);
1840 : }
1841 76228 : }
1842 :
1843 : /*
1844 : * ExecPrepareTupleRouting --- prepare for routing one tuple
1845 : *
1846 : * Determine the partition in which the tuple in slot is to be inserted,
1847 : * and modify mtstate and estate to prepare for it.
1848 : *
1849 : * Caller must revert the estate changes after executing the insertion!
1850 : * In mtstate, transition capture changes may also need to be reverted.
1851 : *
1852 : * Returns a slot holding the tuple of the partition rowtype.
1853 : */
1854 : static TupleTableSlot *
1855 290690 : ExecPrepareTupleRouting(ModifyTableState *mtstate,
1856 : EState *estate,
1857 : PartitionTupleRouting *proute,
1858 : ResultRelInfo *targetRelInfo,
1859 : TupleTableSlot *slot)
1860 : {
1861 : ResultRelInfo *partrel;
1862 : PartitionRoutingInfo *partrouteinfo;
1863 : TupleConversionMap *map;
1864 :
1865 : /*
1866 : * Lookup the target partition's ResultRelInfo. If ExecFindPartition does
1867 : * not find a valid partition for the tuple in 'slot' then an error is
1868 : * raised. An error may also be raised if the found partition is not a
1869 : * valid target for INSERTs. This is required since a partitioned table
1870 : * UPDATE to another partition becomes a DELETE+INSERT.
1871 : */
1872 290690 : partrel = ExecFindPartition(mtstate, targetRelInfo, proute, slot, estate);
1873 290594 : partrouteinfo = partrel->ri_PartitionInfo;
1874 : Assert(partrouteinfo != NULL);
1875 :
1876 : /*
1877 : * Make it look like we are inserting into the partition.
1878 : */
1879 290594 : estate->es_result_relation_info = partrel;
1880 :
1881 : /*
1882 : * If we're capturing transition tuples, we might need to convert from the
1883 : * partition rowtype to root partitioned table's rowtype.
1884 : */
1885 290594 : if (mtstate->mt_transition_capture != NULL)
1886 : {
1887 112 : if (partrel->ri_TrigDesc &&
1888 28 : partrel->ri_TrigDesc->trig_insert_before_row)
1889 : {
1890 : /*
1891 : * If there are any BEFORE triggers on the partition, we'll have
1892 : * to be ready to convert their result back to tuplestore format.
1893 : */
1894 16 : mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
1895 32 : mtstate->mt_transition_capture->tcs_map =
1896 16 : partrouteinfo->pi_PartitionToRootMap;
1897 : }
1898 : else
1899 : {
1900 : /*
1901 : * Otherwise, just remember the original unconverted tuple, to
1902 : * avoid a needless round trip conversion.
1903 : */
1904 68 : mtstate->mt_transition_capture->tcs_original_insert_tuple = slot;
1905 68 : mtstate->mt_transition_capture->tcs_map = NULL;
1906 : }
1907 : }
1908 290594 : if (mtstate->mt_oc_transition_capture != NULL)
1909 : {
1910 72 : mtstate->mt_oc_transition_capture->tcs_map =
1911 36 : partrouteinfo->pi_PartitionToRootMap;
1912 : }
1913 :
1914 : /*
1915 : * Convert the tuple, if necessary.
1916 : */
1917 290594 : map = partrouteinfo->pi_RootToPartitionMap;
1918 290594 : if (map != NULL)
1919 : {
1920 44880 : TupleTableSlot *new_slot = partrouteinfo->pi_PartitionTupleSlot;
1921 :
1922 44880 : slot = execute_attr_map_slot(map->attrMap, slot, new_slot);
1923 : }
1924 :
1925 290594 : return slot;
1926 : }
1927 :
1928 : /*
1929 : * Initialize the child-to-root tuple conversion map array for UPDATE subplans.
1930 : *
1931 : * This map array is required to convert the tuple from the subplan result rel
1932 : * to the target table descriptor. This requirement arises for two independent
1933 : * scenarios:
1934 : * 1. For update-tuple-routing.
1935 : * 2. For capturing tuples in transition tables.
1936 : */
1937 : static void
1938 684 : ExecSetupChildParentMapForSubplan(ModifyTableState *mtstate)
1939 : {
1940 684 : ResultRelInfo *targetRelInfo = getTargetResultRelInfo(mtstate);
1941 684 : ResultRelInfo *resultRelInfos = mtstate->resultRelInfo;
1942 : TupleDesc outdesc;
1943 684 : int numResultRelInfos = mtstate->mt_nplans;
1944 : int i;
1945 :
1946 : /*
1947 : * Build array of conversion maps from each child's TupleDesc to the one
1948 : * used in the target relation. The map pointers may be NULL when no
1949 : * conversion is necessary, which is hopefully a common case.
1950 : */
1951 :
1952 : /* Get tuple descriptor of the target rel. */
1953 684 : outdesc = RelationGetDescr(targetRelInfo->ri_RelationDesc);
1954 :
1955 684 : mtstate->mt_per_subplan_tupconv_maps = (TupleConversionMap **)
1956 684 : palloc(sizeof(TupleConversionMap *) * numResultRelInfos);
1957 :
1958 2012 : for (i = 0; i < numResultRelInfos; ++i)
1959 : {
1960 2656 : mtstate->mt_per_subplan_tupconv_maps[i] =
1961 1328 : convert_tuples_by_name(RelationGetDescr(resultRelInfos[i].ri_RelationDesc),
1962 : outdesc,
1963 : gettext_noop("could not convert row type"));
1964 : }
1965 684 : }
1966 :
1967 : /*
1968 : * For a given subplan index, get the tuple conversion map.
1969 : */
1970 : static TupleConversionMap *
1971 594 : tupconv_map_for_subplan(ModifyTableState *mtstate, int whichplan)
1972 : {
1973 : /* If nobody else set the per-subplan array of maps, do so ourselves. */
1974 594 : if (mtstate->mt_per_subplan_tupconv_maps == NULL)
1975 0 : ExecSetupChildParentMapForSubplan(mtstate);
1976 :
1977 : Assert(whichplan >= 0 && whichplan < mtstate->mt_nplans);
1978 594 : return mtstate->mt_per_subplan_tupconv_maps[whichplan];
1979 : }
1980 :
1981 : /* ----------------------------------------------------------------
1982 : * ExecModifyTable
1983 : *
1984 : * Perform table modifications as required, and return RETURNING results
1985 : * if needed.
1986 : * ----------------------------------------------------------------
1987 : */
1988 : static TupleTableSlot *
1989 80704 : ExecModifyTable(PlanState *pstate)
1990 : {
1991 80704 : ModifyTableState *node = castNode(ModifyTableState, pstate);
1992 80704 : PartitionTupleRouting *proute = node->mt_partition_tuple_routing;
1993 80704 : EState *estate = node->ps.state;
1994 80704 : CmdType operation = node->operation;
1995 : ResultRelInfo *saved_resultRelInfo;
1996 : ResultRelInfo *resultRelInfo;
1997 : PlanState *subplanstate;
1998 : JunkFilter *junkfilter;
1999 : TupleTableSlot *slot;
2000 : TupleTableSlot *planSlot;
2001 : ItemPointer tupleid;
2002 : ItemPointerData tuple_ctid;
2003 : HeapTupleData oldtupdata;
2004 : HeapTuple oldtuple;
2005 :
2006 80704 : CHECK_FOR_INTERRUPTS();
2007 :
2008 : /*
2009 : * This should NOT get called during EvalPlanQual; we should have passed a
2010 : * subplan tree to EvalPlanQual, instead. Use a runtime test not just
2011 : * Assert because this condition is easy to miss in testing. (Note:
2012 : * although ModifyTable should not get executed within an EvalPlanQual
2013 : * operation, we do have to allow it to be initialized and shut down in
2014 : * case it is within a CTE subplan. Hence this test must be here, not in
2015 : * ExecInitModifyTable.)
2016 : */
2017 80704 : if (estate->es_epqTupleSlot != NULL)
2018 0 : elog(ERROR, "ModifyTable should not be called during EvalPlanQual");
2019 :
2020 : /*
2021 : * If we've already completed processing, don't try to do more. We need
2022 : * this test because ExecPostprocessPlan might call us an extra time, and
2023 : * our subplan's nodes aren't necessarily robust against being called
2024 : * extra times.
2025 : */
2026 80704 : if (node->mt_done)
2027 484 : return NULL;
2028 :
2029 : /*
2030 : * On first call, fire BEFORE STATEMENT triggers before proceeding.
2031 : */
2032 80220 : if (node->fireBSTriggers)
2033 : {
2034 76196 : fireBSTriggers(node);
2035 76188 : node->fireBSTriggers = false;
2036 : }
2037 :
2038 : /* Preload local variables */
2039 80212 : resultRelInfo = node->resultRelInfo + node->mt_whichplan;
2040 80212 : subplanstate = node->mt_plans[node->mt_whichplan];
2041 80212 : junkfilter = resultRelInfo->ri_junkFilter;
2042 :
2043 : /*
2044 : * es_result_relation_info must point to the currently active result
2045 : * relation while we are within this ModifyTable node. Even though
2046 : * ModifyTable nodes can't be nested statically, they can be nested
2047 : * dynamically (since our subplan could include a reference to a modifying
2048 : * CTE). So we have to save and restore the caller's value.
2049 : */
2050 80212 : saved_resultRelInfo = estate->es_result_relation_info;
2051 :
2052 80212 : estate->es_result_relation_info = resultRelInfo;
2053 :
2054 : /*
2055 : * Fetch rows from subplan(s), and execute the required table modification
2056 : * for each row.
2057 : */
2058 : for (;;)
2059 : {
2060 : /*
2061 : * Reset the per-output-tuple exprcontext. This is needed because
2062 : * triggers expect to use that context as workspace. It's a bit ugly
2063 : * to do this below the top level of the plan, however. We might need
2064 : * to rethink this later.
2065 : */
2066 24473244 : ResetPerTupleExprContext(estate);
2067 :
2068 : /*
2069 : * Reset per-tuple memory context used for processing on conflict and
2070 : * returning clauses, to free any expression evaluation storage
2071 : * allocated in the previous cycle.
2072 : */
2073 12276728 : if (pstate->ps_ExprContext)
2074 14564 : ResetExprContext(pstate->ps_ExprContext);
2075 :
2076 12276728 : planSlot = ExecProcNode(subplanstate);
2077 :
2078 12276542 : if (TupIsNull(planSlot))
2079 : {
2080 : /* advance to next subplan if any */
2081 75376 : node->mt_whichplan++;
2082 75376 : if (node->mt_whichplan < node->mt_nplans)
2083 : {
2084 902 : resultRelInfo++;
2085 902 : subplanstate = node->mt_plans[node->mt_whichplan];
2086 902 : junkfilter = resultRelInfo->ri_junkFilter;
2087 902 : estate->es_result_relation_info = resultRelInfo;
2088 902 : EvalPlanQualSetPlan(&node->mt_epqstate, subplanstate->plan,
2089 902 : node->mt_arowmarks[node->mt_whichplan]);
2090 : /* Prepare to convert transition tuples from this child. */
2091 902 : if (node->mt_transition_capture != NULL)
2092 : {
2093 264 : node->mt_transition_capture->tcs_map =
2094 132 : tupconv_map_for_subplan(node, node->mt_whichplan);
2095 : }
2096 902 : if (node->mt_oc_transition_capture != NULL)
2097 : {
2098 0 : node->mt_oc_transition_capture->tcs_map =
2099 0 : tupconv_map_for_subplan(node, node->mt_whichplan);
2100 : }
2101 902 : continue;
2102 : }
2103 : else
2104 74474 : break;
2105 : }
2106 :
2107 : /*
2108 : * Ensure input tuple is the right format for the target relation.
2109 : */
2110 12201166 : if (node->mt_scans[node->mt_whichplan]->tts_ops != planSlot->tts_ops)
2111 : {
2112 11838506 : ExecCopySlot(node->mt_scans[node->mt_whichplan], planSlot);
2113 11838506 : planSlot = node->mt_scans[node->mt_whichplan];
2114 : }
2115 :
2116 : /*
2117 : * If resultRelInfo->ri_usesFdwDirectModify is true, all we need to do
2118 : * here is compute the RETURNING expressions.
2119 : */
2120 12201166 : if (resultRelInfo->ri_usesFdwDirectModify)
2121 : {
2122 : Assert(resultRelInfo->ri_projectReturning);
2123 :
2124 : /*
2125 : * A scan slot containing the data that was actually inserted,
2126 : * updated or deleted has already been made available to
2127 : * ExecProcessReturning by IterateDirectModify, so no need to
2128 : * provide it here.
2129 : */
2130 692 : slot = ExecProcessReturning(resultRelInfo, NULL, planSlot);
2131 :
2132 692 : estate->es_result_relation_info = saved_resultRelInfo;
2133 692 : return slot;
2134 : }
2135 :
2136 12200474 : EvalPlanQualSetSlot(&node->mt_epqstate, planSlot);
2137 12200474 : slot = planSlot;
2138 :
2139 12200474 : tupleid = NULL;
2140 12200474 : oldtuple = NULL;
2141 12200474 : if (junkfilter != NULL)
2142 : {
2143 : /*
2144 : * extract the 'ctid' or 'wholerow' junk attribute.
2145 : */
2146 943030 : if (operation == CMD_UPDATE || operation == CMD_DELETE)
2147 : {
2148 : char relkind;
2149 : Datum datum;
2150 : bool isNull;
2151 :
2152 943030 : relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind;
2153 943030 : if (relkind == RELKIND_RELATION || relkind == RELKIND_MATVIEW)
2154 : {
2155 942812 : datum = ExecGetJunkAttribute(slot,
2156 942812 : junkfilter->jf_junkAttNo,
2157 : &isNull);
2158 : /* shouldn't ever get a null result... */
2159 942812 : if (isNull)
2160 0 : elog(ERROR, "ctid is NULL");
2161 :
2162 942812 : tupleid = (ItemPointer) DatumGetPointer(datum);
2163 942812 : tuple_ctid = *tupleid; /* be sure we don't free ctid!! */
2164 942812 : tupleid = &tuple_ctid;
2165 : }
2166 :
2167 : /*
2168 : * Use the wholerow attribute, when available, to reconstruct
2169 : * the old relation tuple.
2170 : *
2171 : * Foreign table updates have a wholerow attribute when the
2172 : * relation has a row-level trigger. Note that the wholerow
2173 : * attribute does not carry system columns. Foreign table
2174 : * triggers miss seeing those, except that we know enough here
2175 : * to set t_tableOid. Quite separately from this, the FDW may
2176 : * fetch its own junk attrs to identify the row.
2177 : *
2178 : * Other relevant relkinds, currently limited to views, always
2179 : * have a wholerow attribute.
2180 : */
2181 218 : else if (AttributeNumberIsValid(junkfilter->jf_junkAttNo))
2182 : {
2183 170 : datum = ExecGetJunkAttribute(slot,
2184 170 : junkfilter->jf_junkAttNo,
2185 : &isNull);
2186 : /* shouldn't ever get a null result... */
2187 170 : if (isNull)
2188 0 : elog(ERROR, "wholerow is NULL");
2189 :
2190 170 : oldtupdata.t_data = DatumGetHeapTupleHeader(datum);
2191 170 : oldtupdata.t_len =
2192 170 : HeapTupleHeaderGetDatumLength(oldtupdata.t_data);
2193 170 : ItemPointerSetInvalid(&(oldtupdata.t_self));
2194 : /* Historically, view triggers see invalid t_tableOid. */
2195 170 : oldtupdata.t_tableOid =
2196 224 : (relkind == RELKIND_VIEW) ? InvalidOid :
2197 54 : RelationGetRelid(resultRelInfo->ri_RelationDesc);
2198 :
2199 170 : oldtuple = &oldtupdata;
2200 : }
2201 : else
2202 : Assert(relkind == RELKIND_FOREIGN_TABLE);
2203 : }
2204 :
2205 : /*
2206 : * apply the junkfilter if needed.
2207 : */
2208 943030 : if (operation != CMD_DELETE)
2209 113492 : slot = ExecFilterJunk(junkfilter, slot);
2210 : }
2211 :
2212 12200474 : switch (operation)
2213 : {
2214 : case CMD_INSERT:
2215 : /* Prepare for tuple routing if needed. */
2216 11257444 : if (proute)
2217 290394 : slot = ExecPrepareTupleRouting(node, estate, proute,
2218 : resultRelInfo, slot);
2219 11257358 : slot = ExecInsert(node, slot, planSlot,
2220 11257358 : estate, node->canSetTag);
2221 : /* Revert ExecPrepareTupleRouting's state change. */
2222 11256198 : if (proute)
2223 290218 : estate->es_result_relation_info = resultRelInfo;
2224 11256198 : break;
2225 : case CMD_UPDATE:
2226 113492 : slot = ExecUpdate(node, tupleid, oldtuple, slot, planSlot,
2227 113492 : &node->mt_epqstate, estate, node->canSetTag);
2228 113288 : break;
2229 : case CMD_DELETE:
2230 829538 : slot = ExecDelete(node, tupleid, oldtuple, planSlot,
2231 : &node->mt_epqstate, estate,
2232 829538 : true, node->canSetTag,
2233 : false /* changingPart */ , NULL, NULL);
2234 829470 : break;
2235 : default:
2236 0 : elog(ERROR, "unknown operation");
2237 : break;
2238 : }
2239 :
2240 : /*
2241 : * If we got a RETURNING result, return it to caller. We'll continue
2242 : * the work on next call.
2243 : */
2244 12198956 : if (slot)
2245 : {
2246 3342 : estate->es_result_relation_info = saved_resultRelInfo;
2247 3342 : return slot;
2248 : }
2249 : }
2250 :
2251 : /* Restore es_result_relation_info before exiting */
2252 74474 : estate->es_result_relation_info = saved_resultRelInfo;
2253 :
2254 : /*
2255 : * We're done, but fire AFTER STATEMENT triggers before exiting.
2256 : */
2257 74474 : fireASTriggers(node);
2258 :
2259 74474 : node->mt_done = true;
2260 :
2261 74474 : return NULL;
2262 : }
2263 :
2264 : /* ----------------------------------------------------------------
2265 : * ExecInitModifyTable
2266 : * ----------------------------------------------------------------
2267 : */
2268 : ModifyTableState *
2269 76680 : ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
2270 : {
2271 : ModifyTableState *mtstate;
2272 76680 : CmdType operation = node->operation;
2273 76680 : int nplans = list_length(node->plans);
2274 : ResultRelInfo *saved_resultRelInfo;
2275 : ResultRelInfo *resultRelInfo;
2276 : Plan *subplan;
2277 : ListCell *l;
2278 : int i;
2279 : Relation rel;
2280 76680 : bool update_tuple_routing_needed = node->partColsUpdated;
2281 :
2282 : /* check for unsupported flags */
2283 : Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
2284 :
2285 : /*
2286 : * create state structure
2287 : */
2288 76680 : mtstate = makeNode(ModifyTableState);
2289 76680 : mtstate->ps.plan = (Plan *) node;
2290 76680 : mtstate->ps.state = estate;
2291 76680 : mtstate->ps.ExecProcNode = ExecModifyTable;
2292 :
2293 76680 : mtstate->operation = operation;
2294 76680 : mtstate->canSetTag = node->canSetTag;
2295 76680 : mtstate->mt_done = false;
2296 :
2297 76680 : mtstate->mt_plans = (PlanState **) palloc0(sizeof(PlanState *) * nplans);
2298 76680 : mtstate->resultRelInfo = estate->es_result_relations + node->resultRelIndex;
2299 76680 : mtstate->mt_scans = (TupleTableSlot **) palloc0(sizeof(TupleTableSlot *) * nplans);
2300 :
2301 : /* If modifying a partitioned table, initialize the root table info */
2302 76680 : if (node->rootResultRelIndex >= 0)
2303 4160 : mtstate->rootResultRelInfo = estate->es_root_result_relations +
2304 2080 : node->rootResultRelIndex;
2305 :
2306 76680 : mtstate->mt_arowmarks = (List **) palloc0(sizeof(List *) * nplans);
2307 76680 : mtstate->mt_nplans = nplans;
2308 :
2309 : /* set up epqstate with dummy subplan data for the moment */
2310 76680 : EvalPlanQualInit(&mtstate->mt_epqstate, estate, NULL, NIL, node->epqParam);
2311 76680 : mtstate->fireBSTriggers = true;
2312 :
2313 : /*
2314 : * call ExecInitNode on each of the plans to be executed and save the
2315 : * results into the array "mt_plans". This is also a convenient place to
2316 : * verify that the proposed target relations are valid and open their
2317 : * indexes for insertion of new index entries. Note we *must* set
2318 : * estate->es_result_relation_info correctly while we initialize each
2319 : * sub-plan; external modules such as FDWs may depend on that (see
2320 : * contrib/postgres_fdw/postgres_fdw.c: postgresBeginDirectModify()
2321 : * as one example).
2322 : */
2323 76680 : saved_resultRelInfo = estate->es_result_relation_info;
2324 :
2325 76680 : resultRelInfo = mtstate->resultRelInfo;
2326 76680 : i = 0;
2327 154528 : foreach(l, node->plans)
2328 : {
2329 77858 : subplan = (Plan *) lfirst(l);
2330 :
2331 : /* Initialize the usesFdwDirectModify flag */
2332 77858 : resultRelInfo->ri_usesFdwDirectModify = bms_is_member(i,
2333 77858 : node->fdwDirectModifyPlans);
2334 :
2335 : /*
2336 : * Verify result relation is a valid target for the current operation
2337 : */
2338 77858 : CheckValidResultRel(resultRelInfo, operation);
2339 :
2340 : /*
2341 : * If there are indices on the result relation, open them and save
2342 : * descriptors in the result relation info, so that we can add new
2343 : * index entries for the tuples we add/update. We need not do this
2344 : * for a DELETE, however, since deletion doesn't affect indexes. Also,
2345 : * inside an EvalPlanQual operation, the indexes might be open
2346 : * already, since we share the resultrel state with the original
2347 : * query.
2348 : */
2349 77848 : if (resultRelInfo->ri_RelationDesc->rd_rel->relhasindex &&
2350 29658 : operation != CMD_DELETE &&
2351 29658 : resultRelInfo->ri_IndexRelationDescs == NULL)
2352 29640 : ExecOpenIndices(resultRelInfo,
2353 29640 : node->onConflictAction != ONCONFLICT_NONE);
2354 :
2355 : /*
2356 : * If this is an UPDATE and a BEFORE UPDATE trigger is present, the
2357 : * trigger itself might modify the partition-key values. So arrange
2358 : * for tuple routing.
2359 : */
2360 84754 : if (resultRelInfo->ri_TrigDesc &&
2361 8824 : resultRelInfo->ri_TrigDesc->trig_update_before_row &&
2362 : operation == CMD_UPDATE)
2363 780 : update_tuple_routing_needed = true;
2364 :
2365 : /* Now init the plan for this result rel */
2366 77848 : estate->es_result_relation_info = resultRelInfo;
2367 77848 : mtstate->mt_plans[i] = ExecInitNode(subplan, estate, eflags);
2368 155696 : mtstate->mt_scans[i] =
2369 77848 : ExecInitExtraTupleSlot(mtstate->ps.state, ExecGetResultType(mtstate->mt_plans[i]),
2370 : table_slot_callbacks(resultRelInfo->ri_RelationDesc));
2371 :
2372 : /* Also let FDWs init themselves for foreign-table result rels */
2373 155530 : if (!resultRelInfo->ri_usesFdwDirectModify &&
2374 77870 : resultRelInfo->ri_FdwRoutine != NULL &&
2375 188 : resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
2376 : {
2377 188 : List *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
2378 :
2379 188 : resultRelInfo->ri_FdwRoutine->BeginForeignModify(mtstate,
2380 : resultRelInfo,
2381 : fdw_private,
2382 : i,
2383 : eflags);
2384 : }
2385 :
2386 77848 : resultRelInfo++;
2387 77848 : i++;
2388 : }
2389 :
2390 76670 : estate->es_result_relation_info = saved_resultRelInfo;
2391 :
2392 : /* Get the target relation */
2393 76670 : rel = (getTargetResultRelInfo(mtstate))->ri_RelationDesc;
2394 :
2395 : /*
2396 : * If it's not a partitioned table after all, UPDATE tuple routing should
2397 : * not be attempted.
2398 : */
2399 76670 : if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
2400 74590 : update_tuple_routing_needed = false;
2401 :
2402 : /*
2403 : * Build state for tuple routing if it's an INSERT or if it's an UPDATE of
2404 : * partition key.
2405 : */
2406 76670 : if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
2407 636 : (operation == CMD_INSERT || update_tuple_routing_needed))
2408 1846 : mtstate->mt_partition_tuple_routing =
2409 1846 : ExecSetupPartitionTupleRouting(estate, mtstate, rel);
2410 :
2411 : /*
2412 : * Build state for collecting transition tuples. This requires having a
2413 : * valid trigger query context, so skip it in explain-only mode.
2414 : */
2415 76670 : if (!(eflags & EXEC_FLAG_EXPLAIN_ONLY))
2416 76228 : ExecSetupTransitionCaptureState(mtstate, estate);
2417 :
2418 : /*
2419 : * Construct mapping from each of the per-subplan partition attnos to the
2420 : * root attno. This is required when during update row movement the tuple
2421 : * descriptor of a source partition does not match the root partitioned
2422 : * table descriptor. In such a case we need to convert tuples to the root
2423 : * tuple descriptor, because the search for destination partition starts
2424 : * from the root. We'll also need a slot to store these converted tuples.
2425 : * We can skip this setup if it's not a partition key update.
2426 : */
2427 76670 : if (update_tuple_routing_needed)
2428 : {
2429 402 : ExecSetupChildParentMapForSubplan(mtstate);
2430 402 : mtstate->mt_root_tuple_slot = table_slot_create(rel, NULL);
2431 : }
2432 :
2433 : /*
2434 : * Initialize any WITH CHECK OPTION constraints if needed.
2435 : */
2436 76670 : resultRelInfo = mtstate->resultRelInfo;
2437 76670 : i = 0;
2438 77438 : foreach(l, node->withCheckOptionLists)
2439 : {
2440 768 : List *wcoList = (List *) lfirst(l);
2441 768 : List *wcoExprs = NIL;
2442 : ListCell *ll;
2443 :
2444 1902 : foreach(ll, wcoList)
2445 : {
2446 1134 : WithCheckOption *wco = (WithCheckOption *) lfirst(ll);
2447 1134 : ExprState *wcoExpr = ExecInitQual((List *) wco->qual,
2448 : &mtstate->ps);
2449 :
2450 1134 : wcoExprs = lappend(wcoExprs, wcoExpr);
2451 : }
2452 :
2453 768 : resultRelInfo->ri_WithCheckOptions = wcoList;
2454 768 : resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
2455 768 : resultRelInfo++;
2456 768 : i++;
2457 : }
2458 :
2459 : /*
2460 : * Initialize RETURNING projections if needed.
2461 : */
2462 76670 : if (node->returningLists)
2463 : {
2464 : TupleTableSlot *slot;
2465 : ExprContext *econtext;
2466 :
2467 : /*
2468 : * Initialize result tuple slot and assign its rowtype using the first
2469 : * RETURNING list. We assume the rest will look the same.
2470 : */
2471 1602 : mtstate->ps.plan->targetlist = (List *) linitial(node->returningLists);
2472 :
2473 : /* Set up a slot for the output of the RETURNING projection(s) */
2474 1602 : ExecInitResultTupleSlotTL(&mtstate->ps, &TTSOpsVirtual);
2475 1602 : slot = mtstate->ps.ps_ResultTupleSlot;
2476 :
2477 : /* Need an econtext too */
2478 1602 : if (mtstate->ps.ps_ExprContext == NULL)
2479 1602 : ExecAssignExprContext(estate, &mtstate->ps);
2480 1602 : econtext = mtstate->ps.ps_ExprContext;
2481 :
2482 : /*
2483 : * Build a projection for each result rel.
2484 : */
2485 1602 : resultRelInfo = mtstate->resultRelInfo;
2486 3394 : foreach(l, node->returningLists)
2487 : {
2488 1792 : List *rlist = (List *) lfirst(l);
2489 :
2490 1792 : resultRelInfo->ri_returningList = rlist;
2491 1792 : resultRelInfo->ri_projectReturning =
2492 1792 : ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
2493 1792 : resultRelInfo->ri_RelationDesc->rd_att);
2494 1792 : resultRelInfo++;
2495 : }
2496 : }
2497 : else
2498 : {
2499 : /*
2500 : * We still must construct a dummy result tuple type, because InitPlan
2501 : * expects one (maybe should change that?).
2502 : */
2503 75068 : mtstate->ps.plan->targetlist = NIL;
2504 75068 : ExecInitResultTypeTL(&mtstate->ps);
2505 :
2506 75068 : mtstate->ps.ps_ExprContext = NULL;
2507 : }
2508 :
2509 : /* Set the list of arbiter indexes if needed for ON CONFLICT */
2510 76670 : resultRelInfo = mtstate->resultRelInfo;
2511 76670 : if (node->onConflictAction != ONCONFLICT_NONE)
2512 796 : resultRelInfo->ri_onConflictArbiterIndexes = node->arbiterIndexes;
2513 :
2514 : /*
2515 : * If needed, Initialize target list, projection and qual for ON CONFLICT
2516 : * DO UPDATE.
2517 : */
2518 76670 : if (node->onConflictAction == ONCONFLICT_UPDATE)
2519 : {
2520 : ExprContext *econtext;
2521 : TupleDesc relationDesc;
2522 : TupleDesc tupDesc;
2523 :
2524 : /* insert may only have one plan, inheritance is not expanded */
2525 : Assert(nplans == 1);
2526 :
2527 : /* already exists if created by RETURNING processing above */
2528 576 : if (mtstate->ps.ps_ExprContext == NULL)
2529 424 : ExecAssignExprContext(estate, &mtstate->ps);
2530 :
2531 576 : econtext = mtstate->ps.ps_ExprContext;
2532 576 : relationDesc = resultRelInfo->ri_RelationDesc->rd_att;
2533 :
2534 : /* carried forward solely for the benefit of explain */
2535 576 : mtstate->mt_excludedtlist = node->exclRelTlist;
2536 :
2537 : /* create state for DO UPDATE SET operation */
2538 576 : resultRelInfo->ri_onConflict = makeNode(OnConflictSetState);
2539 :
2540 : /* initialize slot for the existing tuple */
2541 1152 : resultRelInfo->ri_onConflict->oc_Existing =
2542 576 : table_slot_create(resultRelInfo->ri_RelationDesc,
2543 576 : &mtstate->ps.state->es_tupleTable);
2544 :
2545 : /* create the tuple slot for the UPDATE SET projection */
2546 576 : tupDesc = ExecTypeFromTL((List *) node->onConflictSet);
2547 1152 : resultRelInfo->ri_onConflict->oc_ProjSlot =
2548 576 : ExecInitExtraTupleSlot(mtstate->ps.state, tupDesc,
2549 : &TTSOpsVirtual);
2550 :
2551 : /* build UPDATE SET projection state */
2552 1152 : resultRelInfo->ri_onConflict->oc_ProjInfo =
2553 1152 : ExecBuildProjectionInfo(node->onConflictSet, econtext,
2554 576 : resultRelInfo->ri_onConflict->oc_ProjSlot,
2555 : &mtstate->ps,
2556 : relationDesc);
2557 :
2558 : /* initialize state to evaluate the WHERE clause, if any */
2559 576 : if (node->onConflictWhere)
2560 : {
2561 : ExprState *qualexpr;
2562 :
2563 110 : qualexpr = ExecInitQual((List *) node->onConflictWhere,
2564 : &mtstate->ps);
2565 110 : resultRelInfo->ri_onConflict->oc_WhereClause = qualexpr;
2566 : }
2567 : }
2568 :
2569 : /*
2570 : * If we have any secondary relations in an UPDATE or DELETE, they need to
2571 : * be treated like non-locked relations in SELECT FOR UPDATE, ie, the
2572 : * EvalPlanQual mechanism needs to be told about them. Locate the
2573 : * relevant ExecRowMarks.
2574 : */
2575 77656 : foreach(l, node->rowMarks)
2576 : {
2577 986 : PlanRowMark *rc = lfirst_node(PlanRowMark, l);
2578 : ExecRowMark *erm;
2579 :
2580 : /* ignore "parent" rowmarks; they are irrelevant at runtime */
2581 986 : if (rc->isParent)
2582 64 : continue;
2583 :
2584 : /* find ExecRowMark (same for all subplans) */
2585 922 : erm = ExecFindRowMark(estate, rc->rti, false);
2586 :
2587 : /* build ExecAuxRowMark for each subplan */
2588 2168 : for (i = 0; i < nplans; i++)
2589 : {
2590 : ExecAuxRowMark *aerm;
2591 :
2592 1246 : subplan = mtstate->mt_plans[i]->plan;
2593 1246 : aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
2594 1246 : mtstate->mt_arowmarks[i] = lappend(mtstate->mt_arowmarks[i], aerm);
2595 : }
2596 : }
2597 :
2598 : /* select first subplan */
2599 76670 : mtstate->mt_whichplan = 0;
2600 76670 : subplan = (Plan *) linitial(node->plans);
2601 76670 : EvalPlanQualSetPlan(&mtstate->mt_epqstate, subplan,
2602 76670 : mtstate->mt_arowmarks[0]);
2603 :
2604 : /*
2605 : * Initialize the junk filter(s) if needed. INSERT queries need a filter
2606 : * if there are any junk attrs in the tlist. UPDATE and DELETE always
2607 : * need a filter, since there's always at least one junk attribute present
2608 : * --- no need to look first. Typically, this will be a 'ctid' or
2609 : * 'wholerow' attribute, but in the case of a foreign data wrapper it
2610 : * might be a set of junk attributes sufficient to identify the remote
2611 : * row.
2612 : *
2613 : * If there are multiple result relations, each one needs its own junk
2614 : * filter. Note multiple rels are only possible for UPDATE/DELETE, so we
2615 : * can't be fooled by some needing a filter and some not.
2616 : *
2617 : * This section of code is also a convenient place to verify that the
2618 : * output of an INSERT or UPDATE matches the target table(s).
2619 : */
2620 : {
2621 76670 : bool junk_filter_needed = false;
2622 :
2623 76670 : switch (operation)
2624 : {
2625 : case CMD_INSERT:
2626 307596 : foreach(l, subplan->targetlist)
2627 : {
2628 243246 : TargetEntry *tle = (TargetEntry *) lfirst(l);
2629 :
2630 243246 : if (tle->resjunk)
2631 : {
2632 0 : junk_filter_needed = true;
2633 0 : break;
2634 : }
2635 : }
2636 64350 : break;
2637 : case CMD_UPDATE:
2638 : case CMD_DELETE:
2639 12320 : junk_filter_needed = true;
2640 12320 : break;
2641 : default:
2642 0 : elog(ERROR, "unknown operation");
2643 : break;
2644 : }
2645 :
2646 76670 : if (junk_filter_needed)
2647 : {
2648 12320 : resultRelInfo = mtstate->resultRelInfo;
2649 25814 : for (i = 0; i < nplans; i++)
2650 : {
2651 : JunkFilter *j;
2652 : TupleTableSlot *junkresslot;
2653 :
2654 13494 : subplan = mtstate->mt_plans[i]->plan;
2655 13494 : if (operation == CMD_INSERT || operation == CMD_UPDATE)
2656 10494 : ExecCheckPlanOutput(resultRelInfo->ri_RelationDesc,
2657 : subplan->targetlist);
2658 :
2659 13494 : junkresslot =
2660 13494 : ExecInitExtraTupleSlot(estate, NULL,
2661 : table_slot_callbacks(resultRelInfo->ri_RelationDesc));
2662 13494 : j = ExecInitJunkFilter(subplan->targetlist,
2663 : junkresslot);
2664 :
2665 13494 : if (operation == CMD_UPDATE || operation == CMD_DELETE)
2666 : {
2667 : /* For UPDATE/DELETE, find the appropriate junk attr now */
2668 : char relkind;
2669 :
2670 13494 : relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind;
2671 13494 : if (relkind == RELKIND_RELATION ||
2672 404 : relkind == RELKIND_MATVIEW ||
2673 : relkind == RELKIND_PARTITIONED_TABLE)
2674 : {
2675 13102 : j->jf_junkAttNo = ExecFindJunkAttribute(j, "ctid");
2676 26204 : if (!AttributeNumberIsValid(j->jf_junkAttNo))
2677 0 : elog(ERROR, "could not find junk ctid column");
2678 : }
2679 392 : else if (relkind == RELKIND_FOREIGN_TABLE)
2680 : {
2681 : /*
2682 : * When there is a row-level trigger, there should be
2683 : * a wholerow attribute.
2684 : */
2685 260 : j->jf_junkAttNo = ExecFindJunkAttribute(j, "wholerow");
2686 : }
2687 : else
2688 : {
2689 132 : j->jf_junkAttNo = ExecFindJunkAttribute(j, "wholerow");
2690 132 : if (!AttributeNumberIsValid(j->jf_junkAttNo))
2691 0 : elog(ERROR, "could not find junk wholerow column");
2692 : }
2693 : }
2694 :
2695 13494 : resultRelInfo->ri_junkFilter = j;
2696 13494 : resultRelInfo++;
2697 : }
2698 : }
2699 : else
2700 : {
2701 64350 : if (operation == CMD_INSERT)
2702 64350 : ExecCheckPlanOutput(mtstate->resultRelInfo->ri_RelationDesc,
2703 : subplan->targetlist);
2704 : }
2705 : }
2706 :
2707 : /*
2708 : * Lastly, if this is not the primary (canSetTag) ModifyTable node, add it
2709 : * to estate->es_auxmodifytables so that it will be run to completion by
2710 : * ExecPostprocessPlan. (It'd actually work fine to add the primary
2711 : * ModifyTable node too, but there's no need.) Note the use of lcons not
2712 : * lappend: we need later-initialized ModifyTable nodes to be shut down
2713 : * before earlier ones. This ensures that we don't throw away RETURNING
2714 : * rows that need to be seen by a later CTE subplan.
2715 : */
2716 76670 : if (!mtstate->canSetTag)
2717 586 : estate->es_auxmodifytables = lcons(mtstate,
2718 : estate->es_auxmodifytables);
2719 :
2720 76670 : return mtstate;
2721 : }
2722 :
2723 : /* ----------------------------------------------------------------
2724 : * ExecEndModifyTable
2725 : *
2726 : * Shuts down the plan.
2727 : *
2728 : * Returns nothing of interest.
2729 : * ----------------------------------------------------------------
2730 : */
2731 : void
2732 74430 : ExecEndModifyTable(ModifyTableState *node)
2733 : {
2734 : int i;
2735 :
2736 : /*
2737 : * Allow any FDWs to shut down
2738 : */
2739 149904 : for (i = 0; i < node->mt_nplans; i++)
2740 : {
2741 75474 : ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
2742 :
2743 150792 : if (!resultRelInfo->ri_usesFdwDirectModify &&
2744 75490 : resultRelInfo->ri_FdwRoutine != NULL &&
2745 172 : resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
2746 172 : resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
2747 : resultRelInfo);
2748 : }
2749 :
2750 : /*
2751 : * Close all the partitioned tables, leaf partitions, and their indices
2752 : * and release the slot used for tuple routing, if set.
2753 : */
2754 74430 : if (node->mt_partition_tuple_routing)
2755 : {
2756 1508 : ExecCleanupTupleRouting(node, node->mt_partition_tuple_routing);
2757 :
2758 1508 : if (node->mt_root_tuple_slot)
2759 324 : ExecDropSingleTupleTableSlot(node->mt_root_tuple_slot);
2760 : }
2761 :
2762 : /*
2763 : * Free the exprcontext
2764 : */
2765 74430 : ExecFreeExprContext(&node->ps);
2766 :
2767 : /*
2768 : * clean out the tuple table
2769 : */
2770 74430 : if (node->ps.ps_ResultTupleSlot)
2771 1520 : ExecClearTuple(node->ps.ps_ResultTupleSlot);
2772 :
2773 : /*
2774 : * Terminate EPQ execution if active
2775 : */
2776 74430 : EvalPlanQualEnd(&node->mt_epqstate);
2777 :
2778 : /*
2779 : * shut down subplans
2780 : */
2781 149904 : for (i = 0; i < node->mt_nplans; i++)
2782 75474 : ExecEndNode(node->mt_plans[i]);
2783 74430 : }
2784 :
2785 : void
2786 0 : ExecReScanModifyTable(ModifyTableState *node)
2787 : {
2788 : /*
2789 : * Currently, we don't need to support rescan on ModifyTable nodes. The
2790 : * semantics of that would be a bit debatable anyway.
2791 : */
2792 0 : elog(ERROR, "ExecReScanModifyTable is not implemented");
2793 : }
|
