/*------------------------------------------------------------------------- * * nodeModifyTable . c * routines to handle ModifyTable nodes . * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * * IDENTIFICATION * src / backend / executor / nodeModifyTable . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /* INTERFACE ROUTINES * ExecInitModifyTable - initialize the ModifyTable node * ExecModifyTable - retrieve the next tuple from the node * ExecEndModifyTable - shut down the ModifyTable node * ExecReScanModifyTable - rescan the ModifyTable node * * NOTES * The ModifyTable node receives input from its outerPlan , which is * the data to insert for INSERT cases , the changed columns ' new * values plus row - locating info for UPDATE and MERGE cases , or just the * row - locating info for DELETE cases . * * The relation to modify can be an ordinary table , a foreign table , or a * view . If it ' s a view , either it has sufficient INSTEAD OF triggers or * this node executes only MERGE . . . DO NOTHING . If the original MERGE * targeted a view not in one of those two categories , earlier processing * already pointed the ModifyTable result relation to an underlying * relation of that other view . This node does process * ri_WithCheckOptions , which may have expressions from those other , * automatically updatable views . * * MERGE runs a join between the source relation and the target table . * If any WHEN NOT MATCHED [ BY TARGET ] clauses are present , then the join * is an outer join that might output tuples without a matching target * tuple . In this case , any unmatched target tuples will have NULL * row - locating info , and only INSERT can be run . But for matched target * tuples , the row - locating info is used to determine the tuple to UPDATE * or DELETE . When all clauses are WHEN MATCHED or WHEN NOT MATCHED BY * SOURCE , all tuples produced by the join will include a matching target * tuple , so all tuples contain row - locating info . * * If the query specifies RETURNING , then the ModifyTable returns a * RETURNING tuple after completing each row insert , update , or delete . * It must be called again to continue the operation . Without RETURNING , * we just loop within the node until all the work is done , then * return NULL . This avoids useless call / return overhead . #include "postgres.h" #include "access/htup_details.h" #include "access/tableam.h" #include "access/xact.h" #include "commands/trigger.h" #include "executor/execPartition.h" #include "executor/executor.h" #include "executor/nodeModifyTable.h" #include "foreign/fdwapi.h" #include "miscadmin.h" #include "nodes/nodeFuncs.h" #include "optimizer/optimizer.h" #include "rewrite/rewriteHandler.h" #include "rewrite/rewriteManip.h" #include "storage/lmgr.h" #include "utils/builtins.h" #include "utils/datum.h" #include "utils/rel.h" #include "utils/snapmgr.h" typedef struct MTTargetRelLookup/* hash key, must be first */ int relationIndex; /* rel's index in resultRelInfo[] array */ /* * Context struct for a ModifyTable operation , containing basic execution * state and some output variables populated by ExecUpdateAct ( ) and * ExecDeleteAct ( ) to report the result of their actions to callers . typedef struct ModifyTableContext/* Operation state */ /* * Slot containing tuple obtained from ModifyTable ' s subplan . Used to * access " junk " columns that are not going to be stored . /* * Information about the changes that were made concurrently to a tuple * being updated or deleted /* * The tuple deleted when doing a cross - partition UPDATE with a RETURNING * clause that refers to OLD columns ( converted to the root ' s tuple * descriptor ) . /* * The tuple projected by the INSERT ' s RETURNING clause , when doing a * cross - partition UPDATE /* * Context struct containing output data specific to UPDATE operations . typedef struct UpdateContextbool crossPartUpdate; /* was it a cross-partition update? */ /* Which index updates are required? */ /* * Lock mode to acquire on the latest tuple version before performing * EvalPlanQual on it static void ExecBatchInsert(ModifyTableState *mtstate,int numSlots,bool canSetTag);static void ExecPendingInserts(EState *estate);static void ExecCrossPartitionUpdateForeignKey(ModifyTableContext *context,static bool ExecOnConflictUpdate(ModifyTableContext *context,bool canSetTag,static TupleTableSlot *ExecPrepareTupleRouting(ModifyTableState *mtstate,static TupleTableSlot *ExecMerge(ModifyTableContext *context,bool canSetTag);static void ExecInitMerge(ModifyTableState *mtstate, EState *estate);static TupleTableSlot *ExecMergeMatched(ModifyTableContext *context,bool canSetTag,bool *matched);static TupleTableSlot *ExecMergeNotMatched(ModifyTableContext *context,bool canSetTag);/* * Verify that the tuples to be produced by INSERT match the * target relation ' s rowtype * * We do this to guard against stale plans . If plan invalidation is * functioning properly then we should never get a failure here , but better * safe than sorry . Note that this is called after we have obtained lock * on the target rel , so the rowtype can ' t change underneath us . * * The plan output is represented by its targetlist , because that makes * handling the dropped - column case easier . * * We used to use this for UPDATE as well , but now the equivalent checks * are done in ExecBuildUpdateProjection . static void int attno = 0 ;/* caller removed junk items already */ if (attno >= resultDesc->natts)"table row type and query-specified row type do not match" ),"Query has too many columns." )));/* * Special cases here should match planner ' s expand_insert_targetlist . if (attr->attisdropped)/* * For a dropped column , we can ' t check atttypid ( it ' s likely 0 ) . * In any case the planner has most likely inserted an INT4 null . * What we insist on is just * some * NULL constant . if (!IsA(tle->expr, Const ) ||Const *) tle->expr)->constisnull)"table row type and query-specified row type do not match" ),"Query provides a value for a dropped column at ordinal position %d." ,else if (attr->attgenerated)/* * For a generated column , the planner will have inserted a null * of the column ' s base type ( to avoid possibly failing on domain * not - null constraints ) . It doesn ' t seem worth insisting on that * exact type though , since a null value is type - independent . As * above , just insist on * some * NULL constant . if (!IsA(tle->expr, Const ) ||Const *) tle->expr)->constisnull)"table row type and query-specified row type do not match" ),"Query provides a value for a generated column at ordinal position %d." ,else /* Normal case: demand type match */ if (exprType((Node *) tle->expr) != attr->atttypid)"table row type and query-specified row type do not match" ),"Table has type %s at ordinal position %d, but query expects %s." ,if (attno != resultDesc->natts)"table row type and query-specified row type do not match" ),"Query has too few columns." )));/* * ExecProcessReturning - - - evaluate a RETURNING list * * context : context for the ModifyTable operation * resultRelInfo : current result rel * cmdType : operation / merge action performed ( INSERT , UPDATE , or DELETE ) * oldSlot : slot holding old tuple deleted or updated * newSlot : slot holding new tuple inserted or updated * planSlot : slot holding tuple returned by top subplan node * * Note : If oldSlot and newSlot are NULL , the FDW should have already provided * econtext ' s scan tuple and its old & new tuples are not needed ( FDW direct - * modify is disabled if the RETURNING list refers to any OLD / NEW values ) . * * Returns a slot holding the result tuple static TupleTableSlot */* Make tuple and any needed join variables available to ExecProject */ switch (cmdType)case CMD_INSERT:case CMD_UPDATE:/* return new tuple by default */ if (newSlot)break ;case CMD_DELETE:/* return old tuple by default */ if (oldSlot)break ;default :"unrecognized commandType: %d" , (int ) cmdType);/* Make old/new tuples available to ExecProject, if required */ if (oldSlot)else if (projectReturning->pi_state.flags & EEO_FLAG_HAS_OLD)else /* No references to OLD columns */ if (newSlot)else if (projectReturning->pi_state.flags & EEO_FLAG_HAS_NEW)else /* No references to NEW columns */ /* * Tell ExecProject whether or not the OLD / NEW rows actually exist . This * information is required to evaluate ReturningExpr nodes and also in * ExecEvalSysVar ( ) and ExecEvalWholeRowVar ( ) . if (oldSlot == NULL)else if (newSlot == NULL)else /* Compute the RETURNING expressions */ return ExecProject(projectReturning);/* * ExecCheckTupleVisible - - verify tuple is visible * * It would not be consistent with guarantees of the higher isolation levels to * proceed with avoiding insertion ( taking speculative insertion ' s alternative * path ) on the basis of another tuple that is not visible to MVCC snapshot . * Check for the need to raise a serialization failure , and do so as necessary . static void if (!IsolationUsesXactSnapshot())return ;if (!table_tuple_satisfies_snapshot(rel, slot, estate->es_snapshot))bool isnull;/* * We should not raise a serialization failure if the conflict is * against a tuple inserted by our own transaction , even if it ' s not * visible to our snapshot . ( This would happen , for example , if * conflicting keys are proposed for insertion in a single command . ) if (!TransactionIdIsCurrentTransactionId(xmin))"could not serialize access due to concurrent update" )));/* * ExecCheckTIDVisible - - convenience variant of ExecCheckTupleVisible ( ) static void /* Redundantly check isolation level */ if (!IsolationUsesXactSnapshot())return ;if (!table_tuple_fetch_row_version(rel, tid, SnapshotAny, tempSlot))"failed to fetch conflicting tuple for ON CONFLICT" );/* * Initialize generated columns handling for a tuple * * This fills the resultRelInfo ' s ri_GeneratedExprsI / ri_NumGeneratedNeededI or * ri_GeneratedExprsU / ri_NumGeneratedNeededU fields , depending on cmdtype . * This is used only for stored generated columns . * * If cmdType = = CMD_UPDATE , the ri_extraUpdatedCols field is filled too . * This is used by both stored and virtual generated columns . * * Note : usually , a given query would need only one of ri_GeneratedExprsI and * ri_GeneratedExprsU per result rel ; but MERGE can need both , and so can * cross - partition UPDATEs , since a partition might be the target of both * UPDATE and INSERT actions . void int natts = tupdesc->natts;int ri_NumGeneratedNeeded;/* Nothing to do if no generated columns */ if (!(tupdesc->constr && (tupdesc->constr->has_generated_stored || tupdesc->constr->has_generated_virtual)))return ;/* * In an UPDATE , we can skip computing any generated columns that do not * depend on any UPDATE target column . But if there is a BEFORE ROW * UPDATE trigger , we cannot skip because the trigger might change more * columns . if (cmdtype == CMD_UPDATE &&else /* * Make sure these data structures are built in the per - query memory * context so they ' ll survive throughout the query . sizeof (ExprState *));0 ;for (int i = 0 ; i < natts; i++)char attgenerated = TupleDescAttr(tupdesc, i)->attgenerated;if (attgenerated)/* Fetch the GENERATED AS expression tree */ 1 );if (expr == NULL)"no generation expression found for column number %d of table \" %s\"" ,1 , RelationGetRelationName(rel));/* * If it ' s an update with a known set of update target columns , * see if we can skip the computation . if (updatedCols)1 , &attrs_used);if (!bms_overlap(updatedCols, attrs_used))continue ; /* need not update this column */ /* No luck, so prepare the expression for execution */ if (attgenerated == ATTRIBUTE_GENERATED_STORED)/* If UPDATE, mark column in resultRelInfo->ri_extraUpdatedCols */ if (cmdtype == CMD_UPDATE)1 - FirstLowInvalidHeapAttributeNumber);if (ri_NumGeneratedNeeded == 0 )/* didn't need it after all */ /* Save in appropriate set of fields */ if (cmdtype == CMD_UPDATE)/* Don't call twice */ true ;else /* Don't call twice */ /* * Compute stored generated columns for a tuple void int natts = tupdesc->natts;bool *nulls;/* We should not be called unless this is true */ /* * Initialize the expressions if we didn ' t already , and check whether we * can exit early because nothing needs to be computed . if (cmdtype == CMD_UPDATE)if (resultRelInfo->ri_GeneratedExprsU == NULL)if (resultRelInfo->ri_NumGeneratedNeededU == 0 )return ;else if (resultRelInfo->ri_GeneratedExprsI == NULL)/* Early exit is impossible given the prior Assert */ 0 );sizeof (*values) * natts);sizeof (*nulls) * natts);sizeof (*nulls) * natts);for (int i = 0 ; i < natts; i++)if (ri_GeneratedExprs[i])bool isnull;/* * We must make a copy of val as we have no guarantees about where * memory for a pass - by - reference Datum is located . if (!isnull)else if (!nulls[i])sizeof (*values) * natts);sizeof (*nulls) * natts);/* * ExecInitInsertProjection * Do one - time initialization of projection data for INSERT tuples . * * INSERT queries may need a projection to filter out junk attrs in the tlist . * * This is also a convenient place to verify that the * output of an INSERT matches the target table . static void bool need_projection = false ;/* Extract non-junk columns of the subplan's result tlist. */ if (!tle->resjunk)else true ;/* * The junk - free list must produce a tuple suitable for the result * relation . /* We'll need a slot matching the table's format. */ /* Build ProjectionInfo if needed (it probably isn't). */ if (need_projection)/* need an expression context to do the projection */ if (mtstate->ps.ps_ExprContext == NULL)true ;/* * ExecInitUpdateProjection * Do one - time initialization of projection data for UPDATE tuples . * * UPDATE always needs a projection , because ( 1 ) there ' s always some junk * attrs , and ( 2 ) we may need to merge values of not - updated columns from * the old tuple into the final tuple . In UPDATE , the tuple arriving from * the subplan contains only new values for the changed columns , plus row * identity info in the junk attrs . * * This is " one - time " for any given result rel , but we might touch more than * one result rel in the course of an inherited UPDATE , and each one needs * its own projection due to possible column order variation . * * This is also a convenient place to verify that the output of an UPDATE * matches the target table ( ExecBuildUpdateProjection does that ) . static void int whichrel;/* * Usually , mt_lastResultIndex matches the target rel . If it happens not * to , we can get the index the hard way with an integer division . if (resultRelInfo != mtstate->resultRelInfo + whichrel)0 && whichrel < mtstate->mt_nrels);/* * For UPDATE , we use the old tuple to fill up missing values in the tuple * produced by the subplan to get the new tuple . We need two slots , both * matching the table ' s desired format . /* need an expression context to do the projection */ if (mtstate->ps.ps_ExprContext == NULL)false , /* subplan did the evaluation */ true ;/* * ExecGetInsertNewTuple * This prepares a " new " tuple ready to be inserted into given result * relation , by removing any junk columns of the plan ' s output tuple * and ( if necessary ) coercing the tuple to the right tuple format . static TupleTableSlot */* * If there ' s no projection to be done , just make sure the slot is of the * right type for the target rel . If the planSlot is the right type we * can use it as - is , else copy the data into ri_newTupleSlot . if (newProj == NULL)if (relinfo->ri_newTupleSlot->tts_ops != planSlot->tts_ops)return relinfo->ri_newTupleSlot;else return planSlot;/* * Else project ; since the projection output slot is ri_newTupleSlot , this * will also fix any slot - type problem . * * Note : currently , this is dead code , because INSERT cases don ' t receive * any junk columns so there ' s never a projection to be done . return ExecProject(newProj);/* * ExecGetUpdateNewTuple * This prepares a " new " tuple by combining an UPDATE subplan ' s output * tuple ( which contains values of changed columns ) with unchanged * columns taken from the old tuple . * * The subplan tuple might also contain junk columns , which are ignored . * Note that the projection also ensures we have a slot of the right type . /* Use a few extra Asserts to protect against outside callers */ return ExecProject(newProj);/* ---------------------------------------------------------------- * ExecInsert * * For INSERT , we have to insert the tuple into the target relation * ( or partition thereof ) and insert appropriate tuples into the index * relations . * * slot contains the new tuple value to be stored . * * Returns RETURNING result if any , otherwise NULL . * * inserted_tuple is the tuple that ' s effectively inserted ; * * insert_destrel is the relation where it was inserted . * These are only set on success . * * This may change the currently active tuple conversion map in * mtstate - > mt_transition_capture , so the callers must take care to * save the previous value to avoid losing track of it . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static TupleTableSlot *bool canSetTag,/* * If the input result relation is a partitioned table , find the leaf * partition to insert the tuple into . if (proute)/* * Open the table ' s indexes , if we have not done so already , so that we * can add new index entries for the inserted tuple . if (resultRelationDesc->rd_rel->relhasindex &&/* * BEFORE ROW INSERT Triggers . * * Note : We fire BEFORE ROW TRIGGERS for every attempted insertion in an * INSERT . . . ON CONFLICT statement . We cannot check for constraint * violations before firing these triggers , because they can change the * values to insert . Also , they can run arbitrary user - defined code with * side - effects that we can ' t cancel by just not inserting the tuple . if (resultRelInfo->ri_TrigDesc &&/* Flush any pending inserts, so rows are visible to the triggers */ if (estate->es_insert_pending_result_relations != NIL)if (!ExecBRInsertTriggers(estate, resultRelInfo, slot))return NULL; /* "do nothing" */ /* INSTEAD OF ROW INSERT Triggers */ if (resultRelInfo->ri_TrigDesc &&if (!ExecIRInsertTriggers(estate, resultRelInfo, slot))return NULL; /* "do nothing" */ else if (resultRelInfo->ri_FdwRoutine)/* * GENERATED expressions might reference the tableoid column , so * ( re - ) initialize tts_tableOid before evaluating them . /* * Compute stored generated columns if (resultRelationDesc->rd_att->constr &&/* * If the FDW supports batching , and batching is requested , accumulate * rows and insert them in batches . Otherwise use the per - row inserts . if (resultRelInfo->ri_BatchSize > 1 )bool flushed = false ;/* * When we ' ve reached the desired batch size , perform the * insertion . if (resultRelInfo->ri_NumSlots == resultRelInfo->ri_BatchSize)true ;if (resultRelInfo->ri_Slots == NULL)sizeof (TupleTableSlot *) *sizeof (TupleTableSlot *) */* * Initialize the batch slots . We don ' t know how many slots will * be needed , so we initialize them as the batch grows , and we * keep them across batches . To mitigate an inefficiency in how * resource owner handles objects with many references ( as with * many slots all referencing the same tuple descriptor ) we copy * the appropriate tuple descriptor for each slot . if (resultRelInfo->ri_NumSlots >= resultRelInfo->ri_NumSlotsInitialized)/* remember how many batch slots we initialized */ /* * If these are the first tuples stored in the buffers , add the * target rel and the mtstate to the * es_insert_pending_result_relations and * es_insert_pending_modifytables lists respectively , except in * the case where flushing was done above , in which case they * would already have been added to the lists , so no need to do * this . if (resultRelInfo->ri_NumSlots == 0 && !flushed)return NULL;/* * insert into foreign table : let the FDW do it if (slot == NULL) /* "do nothing" */ return NULL;/* * AFTER ROW Triggers or RETURNING expressions might reference the * tableoid column , so ( re - ) initialize tts_tableOid before evaluating * them . ( This covers the case where the FDW replaced the slot . ) else /* * Constraints and GENERATED expressions might reference the tableoid * column , so ( re - ) initialize tts_tableOid before evaluating them . /* * Compute stored generated columns if (resultRelationDesc->rd_att->constr &&/* * Check any RLS WITH CHECK policies . * * Normally we should check INSERT policies . But if the insert is the * result of a partition key update that moved the tuple to a new * partition , we should instead check UPDATE policies , because we are * executing policies defined on the target table , and not those * defined on the child partitions . * * If we ' re running MERGE , we refer to the action that we ' re executing * to know if we ' re doing an INSERT or UPDATE to a partition table . if (mtstate->operation == CMD_UPDATE)else if (mtstate->operation == CMD_MERGE)else /* * ExecWithCheckOptions ( ) will skip any WCOs which are not of the kind * we are looking for at this point . if (resultRelInfo->ri_WithCheckOptions != NIL)/* * Check the constraints of the tuple . if (resultRelationDesc->rd_att->constr)/* * Also check the tuple against the partition constraint , if there is * one ; except that if we got here via tuple - routing , we don ' t need to * if there ' s no BR trigger defined on the partition . if (resultRelationDesc->rd_rel->relispartition &&true );if (onconflict != ONCONFLICT_NONE && resultRelInfo->ri_NumIndices > 0 )/* Perform a speculative insertion. */ bool specConflict;/* * Do a non - conclusive check for conflicts first . * * We ' re not holding any locks yet , so this doesn ' t guarantee that * the later insert won ' t conflict . But it avoids leaving behind * a lot of canceled speculative insertions , if you run a lot of * INSERT ON CONFLICT statements that do conflict . * * We loop back here if we find a conflict below , either during * the pre - check , or when we re - check after inserting the tuple * speculatively . Better allow interrupts in case some bug makes * this an infinite loop . false ;if (!ExecCheckIndexConstraints(resultRelInfo, slot, estate,/* committed conflict tuple found */ if (onconflict == ONCONFLICT_UPDATE)/* * In case of ON CONFLICT DO UPDATE , execute the UPDATE * part . Be prepared to retry if the UPDATE fails because * of another concurrent UPDATE / DELETE to the conflict * tuple . if (ExecOnConflictUpdate(context, resultRelInfo,1 );return returning;else goto vlock;else /* * In case of ON CONFLICT DO NOTHING , do nothing . However , * verify that the tuple is visible to the executor ' s MVCC * snapshot at higher isolation levels . * * Using ExecGetReturningSlot ( ) to store the tuple for the * recheck isn ' t that pretty , but we can ' t trivially use * the input slot , because it might not be of a compatible * type . As there ' s no conflicting usage of * ExecGetReturningSlot ( ) in the DO NOTHING case . . . 1 );return NULL;/* * Before we start insertion proper , acquire our " speculative * insertion lock " . Others can use that to wait for us to decide * if we ' re going to go ahead with the insertion , instead of * waiting for the whole transaction to complete . /* insert the tuple, with the speculative token */ 0 ,/* insert index entries for tuple */ false , true ,false );/* adjust the tuple's state accordingly */ /* * Wake up anyone waiting for our decision . They will re - check * the tuple , see that it ' s no longer speculative , and wait on our * XID as if this was a regularly inserted tuple all along . Or if * we killed the tuple , they will see it ' s dead , and proceed as if * the tuple never existed . /* * If there was a conflict , start from the beginning . We ' ll do * the pre - check again , which will now find the conflicting tuple * ( unless it aborts before we get there ) . if (specConflict)goto vlock;/* Since there was no insertion conflict, we're done */ else /* insert the tuple normally */ 0 , NULL);/* insert index entries for tuple */ if (resultRelInfo->ri_NumIndices > 0 )false ,false , NULL, NIL,false );if (canSetTag)/* * If this insert is the result of a partition key update that moved the * tuple to a new partition , put this row into the transition NEW TABLE , * if there is one . We need to do this separately for DELETE and INSERT * because they happen on different tables . if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capturefalse );/* * We ' ve already captured the NEW TABLE row , so make sure any AR * INSERT trigger fired below doesn ' t capture it again . /* AFTER ROW INSERT Triggers */ /* * Check any WITH CHECK OPTION constraints from parent views . We are * required to do this after testing all constraints and uniqueness * violations per the SQL spec , so we do it after actually inserting the * record into the heap and all indexes . * * ExecWithCheckOptions will elog ( ERROR ) if a violation is found , so the * tuple will never be seen , if it violates the WITH CHECK OPTION . * * ExecWithCheckOptions ( ) will skip any WCOs which are not of the kind we * are looking for at this point . if (resultRelInfo->ri_WithCheckOptions != NIL)/* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning)/* * If this is part of a cross - partition UPDATE , and the RETURNING list * refers to any OLD columns , ExecDelete ( ) will have saved the tuple * deleted from the original partition , which we must use here to * compute the OLD column values . Otherwise , all OLD column values * will be NULL . if (context->cpDeletedSlot)/* * Convert the OLD tuple to the new partition ' s format / slot , if * needed . Note that ExecDelete ( ) already converted it to the * root ' s partition ' s format / slot . if (tupconv_map != NULL)/* * For a cross - partition UPDATE , release the old tuple , first making * sure that the result slot has a local copy of any pass - by - reference * values . if (context->cpDeletedSlot)if (context->cpDeletedSlot != oldSlot)if (inserted_tuple)if (insert_destrel)return result;/* ---------------------------------------------------------------- * ExecBatchInsert * * Insert multiple tuples in an efficient way . * Currently , this handles inserting into a foreign table without * RETURNING clause . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void int numSlots,bool canSetTag)int i;int numInserted = numSlots;/* * insert into foreign table : let the FDW do it for (i = 0 ; i < numInserted; i++)/* * AFTER ROW Triggers might reference the tableoid column , so * ( re - ) initialize tts_tableOid before evaluating them . /* AFTER ROW INSERT Triggers */ /* * Check any WITH CHECK OPTION constraints from parent views . See the * comment in ExecInsert . if (resultRelInfo->ri_WithCheckOptions != NIL)if (canSetTag && numInserted > 0 )/* Clean up all the slots, ready for the next batch */ for (i = 0 ; i < numSlots; i++)0 ;/* * ExecPendingInserts - - flushes all pending inserts to the foreign tables static void /* * ExecDeletePrologue - - subroutine for ExecDelete * * Prepare executor state for DELETE . Actually , the only thing we have to do * here is execute BEFORE ROW triggers . We return false if one of them makes * the delete a no - op ; otherwise , return true . static bool if (result)/* BEFORE ROW DELETE triggers */ if (resultRelInfo->ri_TrigDesc &&/* Flush any pending inserts, so rows are visible to the triggers */ if (context->estate->es_insert_pending_result_relations != NIL)return ExecBRDeleteTriggers(context->estate, context->epqstate,return true ;/* * ExecDeleteAct - - subroutine for ExecDelete * * Actually delete the tuple from a plain table . * * Caller is in charge of doing EvalPlanQual as necessary static TM_Resultbool changingPart)return table_tuple_delete(resultRelInfo->ri_RelationDesc, tupleid,true /* wait for commit */ , /* * ExecDeleteEpilogue - - subroutine for ExecDelete * * Closing steps of tuple deletion ; this invokes AFTER FOR EACH ROW triggers , * including the UPDATE triggers if the deletion is being done as part of a * cross - partition tuple move . static void bool changingPart)/* * If this delete is the result of a partition key update that moved the * tuple to a new partition , put this row into the transition OLD TABLE , * if there is one . We need to do this separately for DELETE and INSERT * because they happen on different tables . if (mtstate->operation == CMD_UPDATE && mtstate->mt_transition_capture &&false );/* * We ' ve already captured the OLD TABLE row , so make sure any AR * DELETE trigger fired below doesn ' t capture it again . /* AFTER ROW DELETE Triggers */ /* ---------------------------------------------------------------- * ExecDelete * * DELETE is like UPDATE , except that we delete the tuple and no * index modifications are needed . * * When deleting from a table , tupleid identifies the tuple to delete and * oldtuple is NULL . When deleting through a view INSTEAD OF trigger , * oldtuple is passed to the triggers and identifies what to delete , and * tupleid is invalid . When deleting from a foreign table , tupleid is * invalid ; the FDW has to figure out which row to delete using data from * the planSlot . oldtuple is passed to foreign table triggers ; it is * NULL when the foreign table has no relevant triggers . We use * tupleDeleted to indicate whether the tuple is actually deleted , * callers can use it to decide whether to continue the operation . When * this DELETE is a part of an UPDATE of partition - key , then the slot * returned by EvalPlanQual ( ) is passed back using output parameter * epqreturnslot . * * Returns RETURNING result if any , otherwise NULL . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static TupleTableSlot *bool processReturning,bool changingPart,bool canSetTag,bool *tupleDeleted,bool saveOld;if (tupleDeleted)false ;/* * Prepare for the delete . This includes BEFORE ROW triggers , so we ' re * done if it says we are . if (!ExecDeletePrologue(context, resultRelInfo, tupleid, oldtuple,return NULL;/* INSTEAD OF ROW DELETE Triggers */ if (resultRelInfo->ri_TrigDesc &&bool dodelete;if (!dodelete) /* "do nothing" */ return NULL;else if (resultRelInfo->ri_FdwRoutine)/* * delete from foreign table : let the FDW do it * * We offer the returning slot as a place to store RETURNING data , * although the FDW can return some other slot if it wants . if (slot == NULL) /* "do nothing" */ return NULL;/* * RETURNING expressions might reference the tableoid column , so * ( re ) initialize tts_tableOid before evaluating them . if (TTS_EMPTY(slot))else /* * delete the tuple * * Note : if context - > estate - > es_crosscheck_snapshot isn ' t * InvalidSnapshot , we check that the row to be deleted is visible to * that snapshot , and throw a can ' t - serialize error if not . This is a * special - case behavior needed for referential integrity updates in * transaction - snapshot mode transactions . if (tmresult)switch (result)case TM_SelfModified:/* * The target tuple was already updated or deleted by the * current command , or by a later command in the current * transaction . The former case is possible in a join DELETE * where multiple tuples join to the same target tuple . This * is somewhat questionable , but Postgres has always allowed * it : we just ignore additional deletion attempts . * * The latter case arises if the tuple is modified by a * command in a BEFORE trigger , or perhaps by a command in a * volatile function used in the query . In such situations we * should not ignore the deletion , but it is equally unsafe to * proceed . We don ' t want to discard the original DELETE * while keeping the triggered actions based on its deletion ; * and it would be no better to allow the original DELETE * while discarding updates that it triggered . The row update * carries some information that might be important according * to business rules ; so throwing an error is the only safe * course . * * If a trigger actually intends this type of interaction , it * can re - execute the DELETE and then return NULL to cancel * the outer delete . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be deleted was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));/* Else, already deleted by self; nothing to do */ return NULL;case TM_Ok:break ;case TM_Updated:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent update" )));/* * Already know that we ' re going to need to do EPQ , so * fetch tuple directly into the right slot . switch (result)case TM_Ok:if (TupIsNull(epqslot))/* Tuple not passing quals anymore, exiting... */ return NULL;/* * If requested , skip delete and pass back the * updated row . if (epqreturnslot)return NULL;else goto ldelete;case TM_SelfModified:/* * This can be reached when following an update * chain from a tuple updated by another session , * reaching a tuple that was already updated in * this transaction . If previously updated by this * command , ignore the delete , otherwise error * out . * * See also TM_SelfModified response to * table_tuple_delete ( ) above . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be deleted was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));return NULL;case TM_Deleted:/* tuple already deleted; nothing to do */ return NULL;default :/* * TM_Invisible should be impossible because we ' re * waiting for updated row versions , and would * already have errored out if the first version * is invisible . * * TM_Updated should be impossible , because we ' re * locking the latest version via * TUPLE_LOCK_FLAG_FIND_LAST_VERSION . "unexpected table_tuple_lock status: %u" ,return NULL;false );break ;case TM_Deleted:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent delete" )));/* tuple already deleted; nothing to do */ return NULL;default :"unrecognized table_tuple_delete status: %u" ,return NULL;/* * Note : Normally one would think that we have to delete index tuples * associated with the heap tuple now . . . * * . . . but in POSTGRES , we have no need to do this because VACUUM will * take care of it later . We can ' t delete index tuples immediately * anyway , since the tuple is still visible to other transactions . if (canSetTag)/* Tell caller that the delete actually happened. */ if (tupleDeleted)true ;/* * Process RETURNING if present and if requested . * * If this is part of a cross - partition UPDATE , and the RETURNING list * refers to any OLD column values , save the old tuple here for later * processing of the RETURNING list by ExecInsert ( ) . if (resultRelInfo->ri_projectReturning && (processReturning || saveOld))/* * We have to put the target tuple into a slot , which means first we * gotta fetch it . We can use the trigger tuple slot . if (resultRelInfo->ri_FdwRoutine)/* FDW must have provided a slot containing the deleted row */ else if (oldtuple != NULL)false );else if (!table_tuple_fetch_row_version(resultRelationDesc, tupleid,"failed to fetch deleted tuple for DELETE RETURNING" );/* * If required , save the old tuple for later processing of the * RETURNING list by ExecInsert ( ) . if (saveOld)/* * Convert the tuple into the root partition ' s format / slot , if * needed . ExecInsert ( ) will then convert it to the new * partition ' s format / slot , if necessary . if (tupconv_map != NULL)return NULL;/* * Before releasing the target tuple again , make sure rslot has a * local copy of any pass - by - reference values . return rslot;return NULL;/* * ExecCrossPartitionUpdate - - - Move an updated tuple to another partition . * * This works by first deleting the old tuple from the current partition , * followed by inserting the new tuple into the root parent table , that is , * mtstate - > rootResultRelInfo . It will be re - routed from there to the * correct partition . * * Returns true if the tuple has been successfully moved , or if it ' s found * that the tuple was concurrently deleted so there ' s nothing more to do * for the caller . * * False is returned if the tuple we ' re trying to move is found to have been * concurrently updated . In that case , the caller must check if the updated * tuple that ' s returned in * retry_slot still needs to be re - routed , and call * this function again or perform a regular update accordingly . For MERGE , * the updated tuple is not returned in * retry_slot ; it has its own retry * logic . static bool bool canSetTag,bool tuple_deleted;/* * Disallow an INSERT ON CONFLICT DO UPDATE that causes the original row * to migrate to a different partition . Maybe this can be implemented * some day , but it seems a fringe feature with little redeeming value . if (((ModifyTable *) mtstate->ps.plan)->onConflictAction == ONCONFLICT_UPDATE)"invalid ON UPDATE specification" ),"The result tuple would appear in a different partition than the original tuple." )));/* * When an UPDATE is run directly on a leaf partition , simply fail with a * partition constraint violation error . if (resultRelInfo == mtstate->rootResultRelInfo)/* Initialize tuple routing info if not already done. */ if (mtstate->mt_partition_tuple_routing == NULL)/* Things built here have to last for the query duration. */ /* * Before a partition ' s tuple can be re - routed , it must first be * converted to the root ' s format , so we ' ll need a slot for storing * such tuples . /* * Row movement , part 1 . Delete the tuple , but skip RETURNING processing . * We want to return rows from INSERT . false , /* processReturning */ true , /* changingPart */ false , /* canSetTag */ /* * For some reason if DELETE didn ' t happen ( e . g . trigger prevented it , or * it was already deleted by self , or it was concurrently deleted by * another transaction ) , then we should skip the insert as well ; * otherwise , an UPDATE could cause an increase in the total number of * rows across all partitions , which is clearly wrong . * * For a normal UPDATE , the case where the tuple has been the subject of a * concurrent UPDATE or DELETE would be handled by the EvalPlanQual * machinery , but for an UPDATE that we ' ve translated into a DELETE from * this partition and an INSERT into some other partition , that ' s not * available , because CTID chains can ' t span relation boundaries . We * mimic the semantics to a limited extent by skipping the INSERT if the * DELETE fails to find a tuple . This ensures that two concurrent * attempts to UPDATE the same tuple at the same time can ' t turn one tuple * into two , and that an UPDATE of a just - deleted tuple can ' t resurrect * it . if (!tuple_deleted)/* * epqslot will be typically NULL . But when ExecDelete ( ) finds that * another transaction has concurrently updated the same row , it * re - fetches the row , skips the delete , and epqslot is set to the * re - fetched tuple slot . In that case , we need to do all the checks * again . For MERGE , we leave everything to the caller ( it must do * additional rechecking , and might end up executing a different * action entirely ) . if (mtstate->operation == CMD_MERGE)return *tmresult == TM_Ok;else if (TupIsNull(epqslot))return true ;else /* Fetch the most recent version of old tuple. */ /* ... but first, make sure ri_oldTupleSlot is initialized. */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))if (!table_tuple_fetch_row_version(resultRelInfo->ri_RelationDesc,"failed to fetch tuple being updated" );/* and project the new tuple to retry the UPDATE with */ return false ;/* * resultRelInfo is one of the per - relation resultRelInfos . So we should * convert the tuple into root ' s tuple descriptor if needed , since * ExecInsert ( ) starts the search from root . if (tupconv_map != NULL)/* Tuple routing starts from the root table. */ /* * Reset the transition state that may possibly have been written by * INSERT . if (mtstate->mt_transition_capture)/* We're done moving. */ return true ;/* * ExecUpdatePrologue - - subroutine for ExecUpdate * * Prepare executor state for UPDATE . This includes running BEFORE ROW * triggers . We return false if one of them makes the update a no - op ; * otherwise , return true . static bool if (result)/* * Open the table ' s indexes , if we have not done so already , so that we * can add new index entries for the updated tuple . if (resultRelationDesc->rd_rel->relhasindex &&false );/* BEFORE ROW UPDATE triggers */ if (resultRelInfo->ri_TrigDesc &&/* Flush any pending inserts, so rows are visible to the triggers */ if (context->estate->es_insert_pending_result_relations != NIL)return ExecBRUpdateTriggers(context->estate, context->epqstate,return true ;/* * ExecUpdatePrepareSlot - - subroutine for ExecUpdateAct * * Apply the final modifications to the tuple slot before the update . * ( This is split out because we also need it in the foreign - table code path . ) static void /* * Constraints and GENERATED expressions might reference the tableoid * column , so ( re - ) initialize tts_tableOid before evaluating them . /* * Compute stored generated columns if (resultRelationDesc->rd_att->constr &&/* * ExecUpdateAct - - subroutine for ExecUpdate * * Actually update the tuple , when operating on a plain table . If the * table is a partition , and the command was called referencing an ancestor * partitioned table , this routine migrates the resulting tuple to another * partition . * * The caller is in charge of keeping indexes current as necessary . The * caller is also in charge of doing EvalPlanQual if the tuple is found to * be concurrently updated . However , in case of a cross - partition update , * this routine does it . static TM_Resultbool canSetTag, UpdateContext *updateCxt)bool partition_constraint_failed;false ;/* * If we move the tuple to a new partition , we loop back here to recompute * GENERATED values ( which are allowed to be different across partitions ) * and recheck any RLS policies and constraints . We do not fire any * BEFORE triggers of the new partition , however . /* Fill in GENERATEd columns */ /* ensure slot is independent, consider e.g. EPQ */ /* * If partition constraint fails , this row might get moved to another * partition , in which case we should check the RLS CHECK policy just * before inserting into the new partition , rather than doing it here . * This is because a trigger on that partition might again change the row . * So skip the WCO checks if the partition constraint fails . false );/* Check any RLS UPDATE WITH CHECK policies */ if (!partition_constraint_failed &&/* * ExecWithCheckOptions ( ) will skip any WCOs which are not of the kind * we are looking for at this point . /* * If a partition check failed , try to move the row into the right * partition . if (partition_constraint_failed)/* * ExecCrossPartitionUpdate will first DELETE the row from the * partition it ' s currently in and then insert it back into the root * table , which will re - route it to the correct partition . However , * if the tuple has been concurrently updated , a retry is needed . if (ExecCrossPartitionUpdate(context, resultRelInfo,/* success! */ true ;/* * If the partitioned table being updated is referenced in foreign * keys , queue up trigger events to check that none of them were * violated . No special treatment is needed in * non - cross - partition update situations , because the leaf * partition ' s AR update triggers will take care of that . During * cross - partition updates implemented as delete on the source * partition followed by insert on the destination partition , * AR - UPDATE triggers of the root table ( that is , the table * mentioned in the query ) must be fired . * * NULL insert_destrel means that the move failed to occur , that * is , the update failed , so no need to anything in that case . if (insert_destrel &&return TM_Ok;/* * No luck , a retry is needed . If running MERGE , we do not do so * here ; instead let it handle that on its own rules . if (context->mtstate->operation == CMD_MERGE)return result;/* * ExecCrossPartitionUpdate installed an updated version of the new * tuple in the retry slot ; start over . goto lreplace;/* * Check the constraints of the tuple . We ' ve already checked the * partition constraint above ; however , we must still ensure the tuple * passes all other constraints , so we will call ExecConstraints ( ) and * have it validate all remaining checks . if (resultRelationDesc->rd_att->constr)/* * replace the heap tuple * * Note : if es_crosscheck_snapshot isn ' t InvalidSnapshot , we check that * the row to be updated is visible to that snapshot , and throw a * can ' t - serialize error if not . This is a special - case behavior needed * for referential integrity updates in transaction - snapshot mode * transactions . true /* wait for commit */ , return result;/* * ExecUpdateEpilogue - - subroutine for ExecUpdate * * Closing steps of updating a tuple . Must be called if ExecUpdateAct * returns indicating that the tuple was updated . static void /* insert index entries for tuple if necessary */ if (resultRelInfo->ri_NumIndices > 0 && (updateCxt->updateIndexes != TU_None))true , false ,/* AFTER ROW UPDATE Triggers */ false );/* * Check any WITH CHECK OPTION constraints from parent views . We are * required to do this after testing all constraints and uniqueness * violations per the SQL spec , so we do it after actually updating the * record in the heap and all indexes . * * ExecWithCheckOptions ( ) will skip any WCOs which are not of the kind we * are looking for at this point . if (resultRelInfo->ri_WithCheckOptions != NIL)/* * Queues up an update event using the target root partitioned table ' s * trigger to check that a cross - partition update hasn ' t broken any foreign * keys pointing into it . static void /* * For any foreign keys that point directly into a non - root ancestors of * the source partition , we can in theory fire an update event to enforce * those constraints using their triggers , if we could tell that both the * source and the destination partitions are under the same ancestor . But * for now , we simply report an error that those cannot be enforced . bool has_noncloned_fkey = false ;/* Root ancestor's triggers will be processed. */ if (rInfo == rootRelInfo)continue ;if (trigdesc && trigdesc->trig_update_after_row)for (int i = 0 ; i < trigdesc->numtriggers; i++)if (!trig->tgisclone &&true ;break ;if (has_noncloned_fkey)"cannot move tuple across partitions when a non-root ancestor of the source partition is directly referenced in a foreign key" ),"A foreign key points to ancestor \" %s\" but not the root ancestor \" %s\"." ,"Consider defining the foreign key on table \" %s\"." ,/* Perform the root table's triggers. */ true );/* ---------------------------------------------------------------- * ExecUpdate * * note : we can ' t run UPDATE queries with transactions * off because UPDATEs are actually INSERTs and our * scan will mistakenly loop forever , updating the tuple * it just inserted . . This should be fixed but until it * is , we don ' t want to get stuck in an infinite loop * which corrupts your database . . * * When updating a table , tupleid identifies the tuple to update and * oldtuple is NULL . When updating through a view INSTEAD OF trigger , * oldtuple is passed to the triggers and identifies what to update , and * tupleid is invalid . When updating a foreign table , tupleid is * invalid ; the FDW has to figure out which row to update using data from * the planSlot . oldtuple is passed to foreign table triggers ; it is * NULL when the foreign table has no relevant triggers . * * oldSlot contains the old tuple value . * slot contains the new tuple value to be stored . * planSlot is the output of the ModifyTable ' s subplan ; we use it * to access values from other input tables ( for RETURNING ) , * row - ID junk columns , etc . * * Returns RETURNING result if any , otherwise NULL . On exit , if tupleid * had identified the tuple to update , it will identify the tuple * actually updated after EvalPlanQual . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static TupleTableSlot *bool canSetTag)0 };/* * abort the operation if not running transactions if (IsBootstrapProcessingMode())"cannot UPDATE during bootstrap" );/* * Prepare for the update . This includes BEFORE ROW triggers , so we ' re * done if it says we are . if (!ExecUpdatePrologue(context, resultRelInfo, tupleid, oldtuple, slot, NULL))return NULL;/* INSTEAD OF ROW UPDATE Triggers */ if (resultRelInfo->ri_TrigDesc &&if (!ExecIRUpdateTriggers(estate, resultRelInfo,return NULL; /* "do nothing" */ else if (resultRelInfo->ri_FdwRoutine)/* Fill in GENERATEd columns */ /* * update in foreign table : let the FDW do it if (slot == NULL) /* "do nothing" */ return NULL;/* * AFTER ROW Triggers or RETURNING expressions might reference the * tableoid column , so ( re - ) initialize tts_tableOid before evaluating * them . ( This covers the case where the FDW replaced the slot . ) else /* * If we generate a new candidate tuple after EvalPlanQual testing , we * must loop back here to try again . ( We don ' t need to redo triggers , * however . If there are any BEFORE triggers then trigger . c will have * done table_tuple_lock to lock the correct tuple , so there ' s no need * to do them again . ) /* * If ExecUpdateAct reports that a cross - partition update was done , * then the RETURNING tuple ( if any ) has been projected and there ' s * nothing else for us to do . if (updateCxt.crossPartUpdate)return context->cpUpdateReturningSlot;switch (result)case TM_SelfModified:/* * The target tuple was already updated or deleted by the * current command , or by a later command in the current * transaction . The former case is possible in a join UPDATE * where multiple tuples join to the same target tuple . This * is pretty questionable , but Postgres has always allowed it : * we just execute the first update action and ignore * additional update attempts . * * The latter case arises if the tuple is modified by a * command in a BEFORE trigger , or perhaps by a command in a * volatile function used in the query . In such situations we * should not ignore the update , but it is equally unsafe to * proceed . We don ' t want to discard the original UPDATE * while keeping the triggered actions based on it ; and we * have no principled way to merge this update with the * previous ones . So throwing an error is the only safe * course . * * If a trigger actually intends this type of interaction , it * can re - execute the UPDATE ( assuming it can figure out how ) * and then return NULL to cancel the outer update . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be updated was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));/* Else, already updated by self; nothing to do */ return NULL;case TM_Ok:break ;case TM_Updated:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent update" )));/* * Already know that we ' re going to need to do EPQ , so * fetch tuple directly into the right slot . switch (result)case TM_Ok:if (TupIsNull(epqslot))/* Tuple not passing quals anymore, exiting... */ return NULL;/* Make sure ri_oldTupleSlot is initialized. */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))if (resultRelInfo->ri_needLockTagTuple)/* Fetch the most recent version of old tuple. */ if (!table_tuple_fetch_row_version(resultRelationDesc,"failed to fetch tuple being updated" );goto redo_act;case TM_Deleted:/* tuple already deleted; nothing to do */ return NULL;case TM_SelfModified:/* * This can be reached when following an update * chain from a tuple updated by another session , * reaching a tuple that was already updated in * this transaction . If previously modified by * this command , ignore the redundant update , * otherwise error out . * * See also TM_SelfModified response to * table_tuple_update ( ) above . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be updated was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));return NULL;default :/* see table_tuple_lock call in ExecDelete() */ "unexpected table_tuple_lock status: %u" ,return NULL;break ;case TM_Deleted:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent delete" )));/* tuple already deleted; nothing to do */ return NULL;default :"unrecognized table_tuple_update status: %u" ,return NULL;if (canSetTag)/* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning)return ExecProcessReturning(context, resultRelInfo, CMD_UPDATE,return NULL;/* * ExecOnConflictUpdate - - - execute UPDATE of INSERT ON CONFLICT DO UPDATE * * Try to lock tuple for update as part of speculative insertion . If * a qual originating from ON CONFLICT DO UPDATE is satisfied , update * ( but still lock row , even though it may not satisfy estate ' s * snapshot ) . * * Returns true if we ' re done ( with or without an update ) , or false if * the caller must retry the INSERT from scratch . static bool bool canSetTag,bool isnull;/* * Parse analysis should have blocked ON CONFLICT for all system * relations , which includes these . There ' s no fundamental obstacle to * supporting this ; we ' d just need to handle LOCKTAG_TUPLE like the other * ExecUpdate ( ) caller . /* Determine lock mode to use */ /* * Lock tuple for update . Don ' t follow updates when tuple cannot be * locked without doing so . A row locking conflict here means our * previous conclusion that the tuple is conclusively committed is not * true anymore . 0 ,switch (test)case TM_Ok:/* success! */ break ;case TM_Invisible:/* * This can occur when a just inserted tuple is updated again in * the same command . E . g . because multiple rows with the same * conflicting key values are inserted . * * This is somewhat similar to the ExecUpdate ( ) TM_SelfModified * case . We do not want to proceed because it would lead to the * same row being updated a second time in some unspecified order , * and in contrast to plain UPDATEs there ' s no historical behavior * to break . * * It is the user ' s responsibility to prevent this situation from * occurring . These problems are why the SQL standard similarly * specifies that for SQL MERGE , an exception must be raised in * the event of an attempt to update the same row twice . if (TransactionIdIsCurrentTransactionId(xmin))/* translator: %s is a SQL command name */ "%s command cannot affect row a second time" ,"ON CONFLICT DO UPDATE" ),"Ensure that no rows proposed for insertion within the same command have duplicate constrained values." )));/* This shouldn't happen */ "attempted to lock invisible tuple" );break ;case TM_SelfModified:/* * This state should never be reached . As a dirty snapshot is used * to find conflicting tuples , speculative insertion wouldn ' t have * seen this row to conflict with . "unexpected self-updated tuple" );break ;case TM_Updated:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent update" )));/* * Tell caller to try again from the very start . * * It does not make sense to use the usual EvalPlanQual ( ) style * loop here , as the new version of the row might not conflict * anymore , or the conflicting tuple has actually been deleted . return false ;case TM_Deleted:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent delete" )));/* see TM_Updated case */ return false ;default :"unrecognized table_tuple_lock status: %u" , test);/* Success, the tuple is locked. */ /* * Verify that the tuple is visible to our MVCC snapshot if the current * isolation level mandates that . * * It ' s not sufficient to rely on the check within ExecUpdate ( ) as e . g . * CONFLICT . . . WHERE clause may prevent us from reaching that . * * This means we only ever continue when a new command in the current * transaction could see the row , even though in READ COMMITTED mode the * tuple will not be visible according to the current statement ' s * snapshot . This is in line with the way UPDATE deals with newer tuple * versions . /* * Make tuple and any needed join variables available to ExecQual and * ExecProject . The EXCLUDED tuple is installed in ecxt_innertuple , while * the target ' s existing tuple is installed in the scantuple . EXCLUDED * has been made to reference INNER_VAR in setrefs . c , but there is no * other redirection . if (!ExecQual(onConflictSetWhere, econtext))/* see return below */ 1 );return true ; /* done with the tuple */ if (resultRelInfo->ri_WithCheckOptions != NIL)/* * Check target ' s existing tuple against UPDATE - applicable USING * security barrier quals ( if any ) , enforced here as RLS checks / WCOs . * * The rewriter creates UPDATE RLS checks / WCOs for UPDATE security * quals , and stores them as WCOs of " kind " WCO_RLS_CONFLICT_CHECK , * but that ' s almost the extent of its special handling for ON * CONFLICT DO UPDATE . * * The rewriter will also have associated UPDATE applicable straight * RLS checks / WCOs for the benefit of the ExecUpdate ( ) call that * follows . INSERTs and UPDATEs naturally have mutually exclusive WCO * kinds , so there is no danger of spurious over - enforcement in the * INSERT or UPDATE path . /* Project the new tuple version */ /* * Note that it is possible that the target tuple has been modified in * this session , after the above table_tuple_lock . We choose to not error * out in that case , in line with ExecUpdate ' s treatment of similar cases . * This can happen if an UPDATE is triggered from within ExecQual ( ) , * ExecWithCheckOptions ( ) or ExecProject ( ) above , e . g . by selecting from a * wCTE in the ON CONFLICT ' s SET . /* Execute UPDATE with projection */ /* * Clear out existing tuple , as there might not be another conflict among * the next input rows . Don ' t want to hold resources till the end of the * query . First though , make sure that the returning slot , if any , has a * local copy of any OLD pass - by - reference values , if it refers to any OLD * columns . if (*returning != NULL &&return true ;/* * Perform MERGE . static TupleTableSlot *bool canSetTag)bool matched;/*----- * If we are dealing with a WHEN MATCHED case , tupleid or oldtuple is * valid , depending on whether the result relation is a table or a view . * We execute the first action for which the additional WHEN MATCHED AND * quals pass . If an action without quals is found , that action is * executed . * * Similarly , in the WHEN NOT MATCHED BY SOURCE case , tupleid or oldtuple * is valid , and we look at the given WHEN NOT MATCHED BY SOURCE actions * in sequence until one passes . This is almost identical to the WHEN * MATCHED case , and both cases are handled by ExecMergeMatched ( ) . * * Finally , in the WHEN NOT MATCHED [ BY TARGET ] case , both tupleid and * oldtuple are invalid , and we look at the given WHEN NOT MATCHED [ BY * TARGET ] actions in sequence until one passes . * * Things get interesting in case of concurrent update / delete of the * target tuple . Such concurrent update / delete is detected while we are * executing a WHEN MATCHED or WHEN NOT MATCHED BY SOURCE action . * * A concurrent update can : * * 1 . modify the target tuple so that the results from checking any * additional quals attached to WHEN MATCHED or WHEN NOT MATCHED BY * SOURCE actions potentially change , but the result from the join * quals does not change . * * In this case , we are still dealing with the same kind of match * ( MATCHED or NOT MATCHED BY SOURCE ) . We recheck the same list of * actions from the start and choose the first one that satisfies the * new target tuple . * * 2 . modify the target tuple in the WHEN MATCHED case so that the join * quals no longer pass and hence the source and target tuples no * longer match . * * In this case , we are now dealing with a NOT MATCHED case , and we * process both WHEN NOT MATCHED BY SOURCE and WHEN NOT MATCHED [ BY * TARGET ] actions . First ExecMergeMatched ( ) processes the list of * WHEN NOT MATCHED BY SOURCE actions in sequence until one passes , * then ExecMergeNotMatched ( ) processes any WHEN NOT MATCHED [ BY * TARGET ] actions in sequence until one passes . Thus we may execute * two actions ; one of each kind . * * Thus we support concurrent updates that turn MATCHED candidate rows * into NOT MATCHED rows . However , we do not attempt to support cases * that would turn NOT MATCHED rows into MATCHED rows , or which would * cause a target row to match a different source row . * * A concurrent delete changes a WHEN MATCHED case to WHEN NOT MATCHED * [ BY TARGET ] . * * ExecMergeMatched ( ) takes care of following the update chain and * re - finding the qualifying WHEN MATCHED or WHEN NOT MATCHED BY SOURCE * action , as long as the target tuple still exists . If the target tuple * gets deleted or a concurrent update causes the join quals to fail , it * returns a matched status of false and we call ExecMergeNotMatched ( ) . * Given that ExecMergeMatched ( ) always makes progress by following the * update chain and we never switch from ExecMergeNotMatched ( ) to * ExecMergeMatched ( ) , there is no risk of a livelock . if (matched)/* * Deal with the NOT MATCHED case ( either a NOT MATCHED tuple from the * join , or a previously MATCHED tuple for which ExecMergeMatched ( ) set * " matched " to false , indicating that it no longer matches ) . if (!matched)/* * If a concurrent update turned a MATCHED case into a NOT MATCHED * case , and we have both WHEN NOT MATCHED BY SOURCE and WHEN NOT * MATCHED [ BY TARGET ] actions , and there is a RETURNING clause , * ExecMergeMatched ( ) may have already executed a WHEN NOT MATCHED BY * SOURCE action , and computed the row to return . If so , we cannot * execute a WHEN NOT MATCHED [ BY TARGET ] action now , so mark it as * pending ( to be processed on the next call to ExecModifyTable ( ) ) . * Otherwise , just process the action now . if (rslot == NULL)else return rslot;/* * Check and execute the first qualifying MATCHED or NOT MATCHED BY SOURCE * action , depending on whether the join quals are satisfied . If the target * relation is a table , the current target tuple is identified by tupleid . * Otherwise , if the target relation is a view , oldtuple is the current target * tuple from the view . * * We start from the first WHEN MATCHED or WHEN NOT MATCHED BY SOURCE action * and check if the WHEN quals pass , if any . If the WHEN quals for the first * action do not pass , we check the second , then the third and so on . If we * reach the end without finding a qualifying action , we return NULL . * Otherwise , we execute the qualifying action and return its RETURNING * result , if any , or NULL . * * On entry , " * matched " is assumed to be true . If a concurrent update or * delete is detected that causes the join quals to no longer pass , we set it * to false , indicating that the caller should process any NOT MATCHED [ BY * TARGET ] actions . * * After a concurrent update , we restart from the first action to look for a * new qualifying action to execute . If the join quals originally passed , and * the concurrent update caused them to no longer pass , then we switch from * the MATCHED to the NOT MATCHED BY SOURCE list of actions before restarting * ( and setting " * matched " to false ) . As a result we may execute a WHEN NOT * MATCHED BY SOURCE action , and set " * matched " to false , causing the caller * to also execute a WHEN NOT MATCHED [ BY TARGET ] action . static TupleTableSlot *bool canSetTag,bool *matched)bool isNull;/* Expect matched to be true on entry */ /* * If there are no WHEN MATCHED or WHEN NOT MATCHED BY SOURCE actions , we * are done . if (mergeActions[MERGE_WHEN_MATCHED] == NIL &&return NULL;/* * Make tuple and any needed join variables available to ExecQual and * ExecProject . The target ' s existing tuple is installed in the scantuple . * This target relation ' s slot is required only in the case of a MATCHED * or NOT MATCHED BY SOURCE tuple and UPDATE / DELETE actions . /* * This routine is only invoked for matched target rows , so we should * either have the tupleid of the target row , or an old tuple from the * target wholerow junk attr . if (oldtuple != NULL)false );else if (resultRelInfo->ri_needLockTagTuple)/* * This locks even for CMD_DELETE , for CMD_NOTHING , and for tuples * that don ' t match mas_whenqual . MERGE on system catalogs is a * minor use case , so don ' t bother optimizing those . if (!table_tuple_fetch_row_version(resultRelInfo->ri_RelationDesc,"failed to fetch the target tuple" );/* * Test the join condition . If it ' s satisfied , perform a MATCHED action . * Otherwise , perform a NOT MATCHED BY SOURCE action . * * Note that this join condition will be NULL if there are no NOT MATCHED * BY SOURCE actions - - - see transform_MERGE_to_join ( ) . In that case , we * need only consider MATCHED actions here . if (ExecQual(resultRelInfo->ri_MergeJoinCondition, econtext))else 0 };/* * Test condition , if any . * * In the absence of any condition , we perform the action * unconditionally ( no need to check separately since ExecQual ( ) will * return true if there are no conditions to evaluate ) . if (!ExecQual(relaction->mas_whenqual, econtext))continue ;/* * Check if the existing target tuple meets the USING checks of * UPDATE / DELETE RLS policies . If those checks fail , we throw an * error . * * The WITH CHECK quals for UPDATE RLS policies are applied in * ExecUpdateAct ( ) and hence we need not do anything special to handle * them . * * NOTE : We must do this after WHEN quals are evaluated , so that we * check policies only when they matter . if (resultRelInfo->ri_WithCheckOptions && commandType != CMD_NOTHING)/* Perform stated action */ switch (commandType)case CMD_UPDATE:/* * Project the output tuple , and use that to update the table . * We don ' t need to filter out junk attributes , because the * UPDATE action ' s targetlist doesn ' t have any . if (!ExecUpdatePrologue(context, resultRelInfo,if (result == TM_Ok)goto out; /* "do nothing" */ break ; /* concurrent update/delete */ /* INSTEAD OF ROW UPDATE Triggers */ if (resultRelInfo->ri_TrigDesc &&if (!ExecIRUpdateTriggers(estate, resultRelInfo,goto out; /* "do nothing" */ else /* checked ri_needLockTagTuple above */ /* * As in ExecUpdate ( ) , if ExecUpdateAct ( ) reports that a * cross - partition update was done , then there ' s nothing * else for us to do - - - the UPDATE has been turned into a * DELETE and an INSERT , and we must not perform any of * the usual post - update tasks . Also , the RETURNING tuple * ( if any ) has been projected , so we can just return * that . if (updateCxt.crossPartUpdate)1 ;goto out;if (result == TM_Ok)1 ;break ;case CMD_DELETE:if (!ExecDeletePrologue(context, resultRelInfo, tupleid,if (result == TM_Ok)goto out; /* "do nothing" */ break ; /* concurrent update/delete */ /* INSTEAD OF ROW DELETE Triggers */ if (resultRelInfo->ri_TrigDesc &&if (!ExecIRDeleteTriggers(estate, resultRelInfo,goto out; /* "do nothing" */ else /* checked ri_needLockTagTuple above */ false );if (result == TM_Ok)false );1 ;break ;case CMD_NOTHING:/* Doing nothing is always OK */ break ;default :"unknown action in MERGE WHEN clause" );switch (result)case TM_Ok:/* all good; perform final actions */ if (canSetTag && commandType != CMD_NOTHING)break ;case TM_SelfModified:/* * The target tuple was already updated or deleted by the * current command , or by a later command in the current * transaction . The former case is explicitly disallowed by * the SQL standard for MERGE , which insists that the MERGE * join condition should not join a target row to more than * one source row . * * The latter case arises if the tuple is modified by a * command in a BEFORE trigger , or perhaps by a command in a * volatile function used in the query . In such situations we * should not ignore the MERGE action , but it is equally * unsafe to proceed . We don ' t want to discard the original * MERGE action while keeping the triggered actions based on * it ; and it would be no better to allow the original MERGE * action while discarding the updates that it triggered . So * throwing an error is the only safe course . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be updated or deleted was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));if (TransactionIdIsCurrentTransactionId(context->tmfd.xmax))/* translator: %s is a SQL command name */ "%s command cannot affect row a second time" ,"MERGE" ),"Ensure that not more than one source row matches any one target row." )));/* This shouldn't happen */ "attempted to update or delete invisible tuple" );break ;case TM_Deleted:if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent delete" )));/* * If the tuple was already deleted , set matched to false to * let caller handle it under NOT MATCHED [ BY TARGET ] clauses . false ;goto out;case TM_Updated:bool was_matched;if (IsolationUsesXactSnapshot())"could not serialize access due to concurrent update" )));/* * The target tuple was concurrently updated by some other * transaction . If we are currently processing a MATCHED * action , use EvalPlanQual ( ) with the new version of the * tuple and recheck the join qual , to detect a change * from the MATCHED to the NOT MATCHED cases . If we are * already processing a NOT MATCHED BY SOURCE action , we * skip this ( cannot switch from NOT MATCHED BY SOURCE to * MATCHED ) . if (was_matched)else switch (result)case TM_Ok:/* * If the tuple was updated and migrated to * another partition concurrently , the current * MERGE implementation can ' t follow . There ' s * probably a better way to handle this case , but * it ' d require recognizing the relation to which * the tuple moved , and setting our current * resultRelInfo to that . if (ItemPointerIndicatesMovedPartitions(tupleid))"tuple to be merged was already moved to another partition due to concurrent update" )));/* * If this was a MATCHED case , use EvalPlanQual ( ) * to recheck the join condition . if (was_matched)/* * If the subplan didn ' t return a tuple , then * we must be dealing with an inner join for * which the join condition no longer matches . * This can only happen if there are no NOT * MATCHED actions , and so there is nothing * more to do . if (TupIsNull(epqslot))goto out;/* * If we got a NULL ctid from the subplan , the * join quals no longer pass and we switch to * the NOT MATCHED BY SOURCE case . void ) ExecGetJunkAttribute(epqslot,if (isNull)false ;/* * Otherwise , recheck the join quals to see if * we need to switch to the NOT MATCHED BY * SOURCE case . if (resultRelInfo->ri_needLockTagTuple)if (ItemPointerIsValid(&lockedtid))if (!table_tuple_fetch_row_version(resultRelationDesc,"failed to fetch the target tuple" );if (*matched)/* Switch lists, if necessary */ if (!*matched)/* * If we have both NOT MATCHED BY SOURCE * and NOT MATCHED BY TARGET actions ( a * full join between the source and target * relations ) , the single previously * matched tuple from the outer plan node * is treated as two not matched tuples , * in the same way as if they had not * matched to start with . Therefore , we * must adjust the outer plan node ' s tuple * count , if we ' re instrumenting the * query , to get the correct " skipped " row * count - - - see show_modifytable_info ( ) . if (outerPlanState(mtstate)->instrument &&1 .0 );/* * Loop back and process the MATCHED or NOT * MATCHED BY SOURCE actions from the start . goto lmerge_matched;case TM_Deleted:/* * tuple already deleted ; tell caller to run NOT * MATCHED [ BY TARGET ] actions false ;goto out;case TM_SelfModified:/* * This can be reached when following an update * chain from a tuple updated by another session , * reaching a tuple that was already updated or * deleted by the current command , or by a later * command in the current transaction . As above , * this should always be treated as an error . if (context->tmfd.cmax != estate->es_output_cid)"tuple to be updated or deleted was already modified by an operation triggered by the current command" ),"Consider using an AFTER trigger instead of a BEFORE trigger to propagate changes to other rows." )));if (TransactionIdIsCurrentTransactionId(context->tmfd.xmax))/* translator: %s is a SQL command name */ "%s command cannot affect row a second time" ,"MERGE" ),"Ensure that not more than one source row matches any one target row." )));/* This shouldn't happen */ "attempted to update or delete invisible tuple" );goto out;default :/* see table_tuple_lock call in ExecDelete() */ "unexpected table_tuple_lock status: %u" ,goto out;case TM_Invisible:case TM_WouldBlock:case TM_BeingModified:/* these should not occur */ "unexpected tuple operation result: %d" , result);break ;/* Process RETURNING if present */ if (resultRelInfo->ri_projectReturning)switch (commandType)case CMD_UPDATE:break ;case CMD_DELETE:break ;case CMD_NOTHING:break ;default :"unrecognized commandType: %d" ,int ) commandType);/* * We ' ve activated one of the WHEN clauses , so we don ' t search * further . This is required behaviour , not an optimization . break ;/* * Successfully executed an action or no qualifying action was found . if (ItemPointerIsValid(&lockedtid))return rslot;/* * Execute the first qualifying NOT MATCHED [ BY TARGET ] action . static TupleTableSlot *bool canSetTag)/* * For INSERT actions , the root relation ' s merge action is OK since the * INSERT ' s targetlist and the WHEN conditions can only refer to the * source relation and hence it does not matter which result relation we * work with . * * XXX does this mean that we can avoid creating copies of actionStates on * partitioned tables , for not - matched actions ? /* * Make source tuple available to ExecQual and ExecProject . We don ' t need * the target tuple , since the WHEN quals and targetlist can ' t refer to * the target columns . /* * Test condition , if any . * * In the absence of any condition , we perform the action * unconditionally ( no need to check separately since ExecQual ( ) will * return true if there are no conditions to evaluate ) . if (!ExecQual(action->mas_whenqual, econtext))continue ;/* Perform stated action */ switch (commandType)case CMD_INSERT:/* * Project the tuple . In case of a partitioned table , the * projection was already built to use the root ' s descriptor , * so we don ' t need to map the tuple here . 1 ;break ;case CMD_NOTHING:/* Do nothing */ break ;default :"unknown action in MERGE WHEN NOT MATCHED clause" );/* * We ' ve activated one of the WHEN clauses , so we don ' t search * further . This is required behaviour , not an optimization . break ;return rslot;/* * Initialize state for execution of MERGE . void int i;if (mergeActionLists == NIL)return ;0 ;if (mtstate->ps.ps_ExprContext == NULL)/* * Create a MergeActionState for each action on the mergeActionList and * add it to either a list of matched actions or not - matched actions . * * Similar logic appears in ExecInitPartitionInfo ( ) , so if changing * anything here , do so there too . 0 ;/* initialize slots for MERGE fetches from this rel */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))/* initialize state for join condition checking */ /* * Build action merge state for this rel . ( For partitions , * equivalent code exists in ExecInitPartitionInfo . ) /* * We create three lists - one for each MergeMatchKind - and stick * the MergeActionState into the appropriate list . switch (action->commandType)case CMD_INSERT:/* INSERT actions always use rootRelInfo */ /* * If the MERGE targets a partitioned table , any INSERT * actions must be routed through it , not the child * relations . Initialize the routing struct and the root * table ' s " new " tuple slot for that , if not already done . * The projection we prepare , for all relations , uses the * root relation descriptor , and targets the plan ' s root * slot . ( This is consistent with the fact that we * checked the plan output to match the root relation , * above . ) if (rootRelInfo->ri_RelationDesc->rd_rel->relkind ==if (mtstate->mt_partition_tuple_routing == NULL)/* * Initialize planstate for routing if not already * done . * * Note that the slot is managed as a standalone * slot belonging to ModifyTableState , so we pass * NULL for the 2 nd argument . else /* * If the MERGE targets an inherited table , we insert * into the root table , so we must initialize its * " new " tuple slot , if not already done , and use its * relation descriptor for the projection . * * For non - inherited tables , rootRelInfo and * resultRelInfo are the same , and the " new " tuple * slot will already have been initialized . if (rootRelInfo->ri_newTupleSlot == NULL)break ;case CMD_UPDATE:true ,break ;case CMD_DELETE:break ;case CMD_NOTHING:break ;default :"unknown action in MERGE WHEN clause" );break ;/* * If the MERGE targets an inherited table , any INSERT actions will use * rootRelInfo , and rootRelInfo will not be in the resultRelInfo array . * Therefore we must initialize its WITH CHECK OPTION constraints and * RETURNING projection , as ExecInitModifyTable did for the resultRelInfo * entries . * * Note that the planner does not build a withCheckOptionList or * returningList for the root relation , but as in ExecInitPartitionInfo , * we can use the first resultRelInfo entry as a reference to calculate * the attno ' s for the root table . if (rootRelInfo != mtstate->resultRelInfo &&0 )0 ].ri_RelationDesc;int firstVarno = mtstate->resultRelInfo[0 ].ri_RangeTableIndex;bool found_whole_row;if (node->withCheckOptionLists != NIL)/* There should be as many WCO lists as result rels */ /* * Use the first WCO list as a reference . In the most common case , * this will be for the same relation as rootRelInfo , and so there * will be no need to adjust its attno ' s . if (rootRelation != firstResultRel)/* Convert any Vars in it to contain the root's attno's */ false );0 ,if (node->returningLists != NIL)/* There should be as many returning lists as result rels */ /* * Use the first returning list as a reference . In the most common * case , this will be for the same relation as rootRelInfo , and so * there will be no need to adjust its attno ' s . if (rootRelation != firstResultRel)/* Convert any Vars in it to contain the root's attno's */ if (part_attmap == NULL)false );0 ,/* Initialize the RETURNING projection */ /* * Initializes the tuple slots in a ResultRelInfo for any MERGE action . * * We mark ' projectNewInfoValid ' even though the projections themselves * are not initialized here . void true ;/* * Process BEFORE EACH STATEMENT triggers static void switch (node->operation)case CMD_INSERT:if (plan->onConflictAction == ONCONFLICT_UPDATE)break ;case CMD_UPDATE:break ;case CMD_DELETE:break ;case CMD_MERGE:if (node->mt_merge_subcommands & MERGE_INSERT)if (node->mt_merge_subcommands & MERGE_UPDATE)if (node->mt_merge_subcommands & MERGE_DELETE)break ;default :"unknown operation" );break ;/* * Process AFTER EACH STATEMENT triggers static void switch (node->operation)case CMD_INSERT:if (plan->onConflictAction == ONCONFLICT_UPDATE)break ;case CMD_UPDATE:break ;case CMD_DELETE:break ;case CMD_MERGE:if (node->mt_merge_subcommands & MERGE_DELETE)if (node->mt_merge_subcommands & MERGE_UPDATE)if (node->mt_merge_subcommands & MERGE_INSERT)break ;default :"unknown operation" );break ;/* * Set up the state needed for collecting transition tuples for AFTER * triggers . static void /* Check for transition tables on the directly targeted relation. */ if (plan->operation == CMD_INSERT &&/* * ExecPrepareTupleRouting - - - prepare for routing one tuple * * Determine the partition in which the tuple in slot is to be inserted , * and return its ResultRelInfo in * partRelInfo . The return value is * a slot holding the tuple of the partition rowtype . * * This also sets the transition table information in mtstate based on the * selected partition . static TupleTableSlot */* * Lookup the target partition ' s ResultRelInfo . If ExecFindPartition does * not find a valid partition for the tuple in ' slot ' then an error is * raised . An error may also be raised if the found partition is not a * valid target for INSERTs . This is required since a partitioned table * UPDATE to another partition becomes a DELETE + INSERT . /* * If we ' re capturing transition tuples , we might need to convert from the * partition rowtype to root partitioned table ' s rowtype . But if there * are no BEFORE triggers on the partition that could change the tuple , we * can just remember the original unconverted tuple to avoid a needless * round trip conversion . if (mtstate->mt_transition_capture != NULL)bool has_before_insert_row_trig;/* * Convert the tuple , if necessary . if (map != NULL)return slot;/* ---------------------------------------------------------------- * ExecModifyTable * * Perform table modifications as required , and return RETURNING results * if needed . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static TupleTableSlot *bool tuplock;/* * This should NOT get called during EvalPlanQual ; we should have passed a * subplan tree to EvalPlanQual , instead . Use a runtime test not just * Assert because this condition is easy to miss in testing . ( Note : * although ModifyTable should not get executed within an EvalPlanQual * operation , we do have to allow it to be initialized and shut down in * case it is within a CTE subplan . Hence this test must be here , not in * ExecInitModifyTable . ) if (estate->es_epq_active != NULL)"ModifyTable should not be called during EvalPlanQual" );/* * If we ' ve already completed processing , don ' t try to do more . We need * this test because ExecPostprocessPlan might call us an extra time , and * our subplan ' s nodes aren ' t necessarily robust against being called * extra times . if (node->mt_done)return NULL;/* * On first call , fire BEFORE STATEMENT triggers before proceeding . if (node->fireBSTriggers)false ;/* Preload local variables */ /* Set global context */ /* * Fetch rows from subplan , and execute the required table modification * for each row . for (;;)/* * Reset the per - output - tuple exprcontext . This is needed because * triggers expect to use that context as workspace . It ' s a bit ugly * to do this below the top level of the plan , however . We might need * to rethink this later . /* * Reset per - tuple memory context used for processing on conflict and * returning clauses , to free any expression evaluation storage * allocated in the previous cycle . if (pstate->ps_ExprContext)/* * If there is a pending MERGE . . . WHEN NOT MATCHED [ BY TARGET ] action * to execute , do so now - - - see the comments in ExecMerge ( ) . if (node->mt_merge_pending_not_matched != NULL)/* Clear the pending action */ /* * If we got a RETURNING result , return it to the caller . We ' ll * continue the work on next call . if (slot)return slot;continue ; /* continue with the next tuple */ /* Fetch the next row from subplan */ /* No more tuples to process? */ if (TupIsNull(context.planSlot))break ;/* * When there are multiple result relations , each tuple contains a * junk column that gives the OID of the rel from which it came . * Extract it and select the correct result relation . if (AttributeNumberIsValid(node->mt_resultOidAttno))bool isNull;if (isNull)/* * For commands other than MERGE , any tuples having InvalidOid * for tableoid are errors . For MERGE , we may need to handle * them as WHEN NOT MATCHED clauses if any , so do that . * * Note that we use the node ' s toplevel resultRelInfo , not any * specific partition ' s . if (operation == CMD_MERGE)/* * If we got a RETURNING result , return it to the caller . * We ' ll continue the work on next call . if (slot)return slot;continue ; /* continue with the next tuple */ "tableoid is NULL" );/* If it's not the same as last time, we need to locate the rel */ if (resultoid != node->mt_lastResultOid)false , true );/* * If resultRelInfo - > ri_usesFdwDirectModify is true , all we need to do * here is compute the RETURNING expressions . if (resultRelInfo->ri_usesFdwDirectModify)/* * A scan slot containing the data that was actually inserted , * updated or deleted has already been made available to * ExecProcessReturning by IterateDirectModify , so no need to * provide it here . The individual old and new slots are not * needed , since direct - modify is disabled if the RETURNING list * refers to OLD / NEW values . 0 0 );return slot;/* * For UPDATE / DELETE / MERGE , fetch the row identity info for the tuple * to be updated / deleted / merged . For a heap relation , that ' s a TID ; * otherwise we may have a wholerow junk attr that carries the old * tuple in toto . Keep this in step with the part of * ExecInitModifyTable that sets up ri_RowIdAttNo . if (operation == CMD_UPDATE || operation == CMD_DELETE ||char relkind;bool isNull;if (relkind == RELKIND_RELATION ||/* * ri_RowIdAttNo refers to a ctid attribute . See the comment * in ExecInitModifyTable ( ) . /* * For commands other than MERGE , any tuples having a null row * identifier are errors . For MERGE , we may need to handle * them as WHEN NOT MATCHED clauses if any , so do that . * * Note that we use the node ' s toplevel resultRelInfo , not any * specific partition ' s . if (isNull)if (operation == CMD_MERGE)/* * If we got a RETURNING result , return it to the * caller . We ' ll continue the work on next call . if (slot)return slot;continue ; /* continue with the next tuple */ "ctid is NULL" );/* be sure we don't free ctid!! */ /* * Use the wholerow attribute , when available , to reconstruct the * old relation tuple . The old tuple serves one or both of two * purposes : 1 ) it serves as the OLD tuple for row triggers , 2 ) it * provides values for any unchanged columns for the NEW tuple of * an UPDATE , because the subplan does not produce all the columns * of the target table . * * Note that the wholerow attribute does not carry system columns , * so foreign table triggers miss seeing those , except that we * know enough here to set t_tableOid . Quite separately from * this , the FDW may fetch its own junk attrs to identify the row . * * Other relevant relkinds , currently limited to views , always * have a wholerow attribute . else if (AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))/* * For commands other than MERGE , any tuples having a null row * identifier are errors . For MERGE , we may need to handle * them as WHEN NOT MATCHED clauses if any , so do that . * * Note that we use the node ' s toplevel resultRelInfo , not any * specific partition ' s . if (isNull)if (operation == CMD_MERGE)/* * If we got a RETURNING result , return it to the * caller . We ' ll continue the work on next call . if (slot)return slot;continue ; /* continue with the next tuple */ "wholerow is NULL" );/* Historically, view triggers see invalid t_tableOid. */ else /* Only foreign tables are allowed to omit a row-ID attr */ switch (operation)case CMD_INSERT:/* Initialize projection info if first time for this table */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))break ;case CMD_UPDATE:false ;/* Initialize projection info if first time for this table */ if (unlikely(!resultRelInfo->ri_projectNewInfoValid))/* * Make the new tuple by combining plan ' s output tuple with * the old tuple being updated . if (oldtuple != NULL)/* Use the wholerow junk attr as the old tuple. */ false );else /* Fetch the most recent version of old tuple. */ if (resultRelInfo->ri_needLockTagTuple)true ;if (!table_tuple_fetch_row_version(relation, tupleid,"failed to fetch tuple being updated" );/* Now apply the update. */ if (tuplock)break ;case CMD_DELETE:true , false , node->canSetTag, NULL, NULL, NULL);break ;case CMD_MERGE:break ;default :"unknown operation" );break ;/* * If we got a RETURNING result , return it to caller . We ' ll continue * the work on next call . if (slot)return slot;/* * Insert remaining tuples for batch insert . if (estate->es_insert_pending_result_relations != NIL)/* * We ' re done , but fire AFTER STATEMENT triggers before exiting . true ;return NULL;/* * ExecLookupResultRelByOid * If the table with given OID is among the result relations to be * updated by the given ModifyTable node , return its ResultRelInfo . * * If not found , return NULL if missing_ok , else raise error . * * If update_cache is true , then upon successful lookup , update the node ' s * one - element cache . ONLY ExecModifyTable may pass true for this . bool missing_ok, bool update_cache)if (node->mt_resultOidHash)/* Use the pre-built hash table to locate the rel */ if (mtlookup)if (update_cache)return node->resultRelInfo + mtlookup->relationIndex;else /* With few target rels, just search the ResultRelInfo array */ for (int ndx = 0 ; ndx < node->mt_nrels; ndx++)if (RelationGetRelid(rInfo->ri_RelationDesc) == resultoid)if (update_cache)return rInfo;if (!missing_ok)"incorrect result relation OID %u" , resultoid);return NULL;/* ---------------------------------------------------------------- * ExecInitModifyTable * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - int eflags)int total_nrels = list_length(node->resultRelations);int nrels;int i;/* check for unsupported flags */ /* * Only consider unpruned relations for initializing their ResultRelInfo * struct and other fields such as withCheckOptions , etc . * * Note : We must avoid pruning every result relation . This is important * for MERGE , since even if every result relation is pruned from the * subplan , there might still be NOT MATCHED rows , for which there may be * INSERT actions to perform . To allow these actions to be found , at * least one result relation must be kept . Also , when inserting into a * partitioned table , ExecInitPartitionInfo ( ) needs a ResultRelInfo struct * as a reference for building the ResultRelInfo of the target partition . * In either case , it doesn ' t matter which result relation is kept , so we * just keep the first one , if all others have been pruned . See also , * ExecDoInitialPruning ( ) , which ensures that this first result relation * has been locked . 0 ;bool keep_rel;if (!keep_rel && i == total_nrels - 1 && resultRelations == NIL)/* all result relations pruned; keep the first one */ true ;0 ;if (keep_rel)if (node->withCheckOptionLists)if (node->returningLists)if (node->updateColnosLists)if (node->mergeActionLists)if (node->mergeJoinConditions)0 );/* * create state structure false ;sizeof (ResultRelInfo));0 ;0 ;0 ;/*---------- * Resolve the target relation . This is the same as : * * - the relation for which we will fire FOR STATEMENT triggers , * - the relation into whose tuple format all captured transition tuples * must be converted , and * - the root partitioned table used for tuple routing . * * If it ' s a partitioned or inherited table , the root partition or * appendrel RTE doesn ' t appear elsewhere in the plan and its RT index is * given explicitly in node - > rootRelation . Otherwise , the target relation * is the sole relation in the node - > resultRelations list and , since it can * never be pruned , also in the resultRelations list constructed above . * - - - - - - - - - - if (node->rootRelation > 0 )else 1 );1 );/* set up epqstate with dummy subplan data for the moment */ true ;/* * Build state for collecting transition tuples . This requires having a * valid trigger query context , so skip it in explain - only mode . if (!(eflags & EXEC_FLAG_EXPLAIN_ONLY))/* * Open all the result relations and initialize the ResultRelInfo structs . * ( But root relation was initialized above , if it ' s part of the array . ) * We must do this before initializing the subplan , because direct - modify * FDWs expect their ResultRelInfos to be available . 0 ;if (mergeActionLists)if (resultRelInfo != mtstate->rootResultRelInfo)/* * For child result relations , store the root result relation * pointer . We do so for the convenience of places that want to * look at the query ' s original target relation but don ' t have the * mtstate handy . /* Initialize the usesFdwDirectModify flag */ /* * Verify result relation is a valid target for the current operation /* * Now we may initialize the subplan . /* * Do additional per - result - relation initialization . for (i = 0 ; i < nrels; i++)/* Let FDWs init themselves for foreign-table result rels */ if (!resultRelInfo->ri_usesFdwDirectModify &&/* * For UPDATE / DELETE / MERGE , find the appropriate junk attr now , either * a ' ctid ' or ' wholerow ' attribute depending on relkind . For foreign * tables , the FDW might have created additional junk attr ( s ) , but * those are no concern of ours . if (operation == CMD_UPDATE || operation == CMD_DELETE ||char relkind;if (relkind == RELKIND_RELATION ||"ctid" );/* * For heap relations , a ctid junk attribute must be present . * Partitioned tables should only appear here when all leaf * partitions were pruned , in which case no rows can be * produced and ctid is not needed . if (relkind == RELKIND_PARTITIONED_TABLE)1 );else if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))"could not find junk ctid column" );else if (relkind == RELKIND_FOREIGN_TABLE)/* * We don ' t support MERGE with foreign tables for now . ( It ' s * problematic because the implementation uses CTID . ) /* * When there is a row - level trigger , there should be a * wholerow attribute . We also require it to be present in * UPDATE and MERGE , so we can get the values of unchanged * columns . "wholerow" );if ((mtstate->operation == CMD_UPDATE || mtstate->operation == CMD_MERGE) &&"could not find junk wholerow column" );else /* Other valid target relkinds must provide wholerow */ "wholerow" );if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))"could not find junk wholerow column" );/* * If this is an inherited update / delete / merge , there will be a junk * attribute named " tableoid " present in the subplan ' s targetlist . It * will be used to identify the result relation for a given tuple to be * updated / deleted / merged . "tableoid" );1 );/* force lookup at first tuple */ 0 ; /* must be zero if no such attr */ /* Get the root target relation */ /* * Build state for tuple routing if it ' s a partitioned INSERT . An UPDATE * or MERGE might need this too , but only if it actually moves tuples * between partitions ; in that case setup is done by * ExecCrossPartitionUpdate . if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&/* * Initialize any WITH CHECK OPTION constraints if needed . /* * Initialize RETURNING projections if needed . if (returningLists)/* * Initialize result tuple slot and assign its rowtype using the plan * node ' s declared targetlist , which the planner set up to be the same * as the first ( before runtime pruning ) RETURNING list . We assume * all the result rels will produce compatible output . /* Need an econtext too */ if (mtstate->ps.ps_ExprContext == NULL)/* * Build a projection for each result rel . else /* * We still must construct a dummy result tuple type , because InitPlan * expects one ( maybe should change that ? ) . /* Set the list of arbiter indexes if needed for ON CONFLICT */ if (node->onConflictAction != ONCONFLICT_NONE)/* insert may only have one relation, inheritance is not expanded */ 1 );/* * If needed , Initialize target list , projection and qual for ON CONFLICT * DO UPDATE . if (node->onConflictAction == ONCONFLICT_UPDATE)/* already exists if created by RETURNING processing above */ if (mtstate->ps.ps_ExprContext == NULL)/* create state for DO UPDATE SET operation */ /* initialize slot for the existing tuple */ /* * Create the tuple slot for the UPDATE SET projection . We want a slot * of the table ' s type here , because the slot will be used to insert * into the table , and for RETURNING processing - which may access * system attributes . /* build UPDATE SET projection state */ true ,/* initialize state to evaluate the WHERE clause, if any */ if (node->onConflictWhere)/* * If we have any secondary relations in an UPDATE or DELETE , they need to * be treated like non - locked relations in SELECT FOR UPDATE , i . e . , the * EvalPlanQual mechanism needs to be told about them . This also goes for * the source relations in a MERGE . Locate the relevant ExecRowMarks . /* ignore "parent" rowmarks; they are irrelevant at runtime */ if (rc->isParent)continue ;/* * Also ignore rowmarks belonging to child tables that have been * pruned in ExecDoInitialPruning ( ) . if (rte->rtekind == RTE_RELATION &&continue ;/* Find ExecRowMark and build ExecAuxRowMark */ false );/* For a MERGE command, initialize its state */ if (mtstate->operation == CMD_MERGE)/* * If there are a lot of result relations , use a hash table to speed the * lookups . If there are not a lot , a simple linear search is faster . * * It ' s not clear where the threshold is , but try 64 for starters . In a * debugging build , use a small threshold so that we get some test * coverage of both code paths . #ifdef USE_ASSERT_CHECKING#define MT_NRELS_HASH 4 #else #define MT_NRELS_HASH 64 #endif if (nrels >= MT_NRELS_HASH)sizeof (Oid);sizeof (MTTargetRelLookup);"ModifyTable target hash" ,for (i = 0 ; i < nrels; i++)bool found;else /* * Determine if the FDW supports batch insert and determine the batch size * ( a FDW may support batching , but it may be disabled for the * server / table ) . * * We only do this for INSERT , so that for UPDATE / DELETE the batch size * remains set to 0 . if (operation == CMD_INSERT)/* insert may only have one relation, inheritance is not expanded */ 1 );if (!resultRelInfo->ri_usesFdwDirectModify &&1 );else 1 ;/* * Lastly , if this is not the primary ( canSetTag ) ModifyTable node , add it * to estate - > es_auxmodifytables so that it will be run to completion by * ExecPostprocessPlan . ( It ' d actually work fine to add the primary * ModifyTable node too , but there ' s no need . ) Note the use of lcons not * lappend : we need later - initialized ModifyTable nodes to be shut down * before earlier ones . This ensures that we don ' t throw away RETURNING * rows that need to be seen by a later CTE subplan . if (!mtstate->canSetTag)return mtstate;/* ---------------------------------------------------------------- * ExecEndModifyTable * * Shuts down the plan . * * Returns nothing of interest . * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - void int i;/* * Allow any FDWs to shut down for (i = 0 ; i < node->mt_nrels; i++)int j;if (!resultRelInfo->ri_usesFdwDirectModify &&/* * Cleanup the initialized batch slots . This only matters for FDWs * with batching , but the other cases will have ri_NumSlotsInitialized * = = 0 . for (j = 0 ; j < resultRelInfo->ri_NumSlotsInitialized; j++)/* * Close all the partitioned tables , leaf partitions , and their indices * and release the slot used for tuple routing , if set . if (node->mt_partition_tuple_routing)if (node->mt_root_tuple_slot)/* * Terminate EPQ execution if active /* * shut down subplan void /* * Currently , we don ' t need to support rescan on ModifyTable nodes . The * semantics of that would be a bit debatable anyway . "ExecReScanModifyTable is not implemented" );
Messung V0.5 in Prozent C=93 H=94 G=93
¤ Dauer der Verarbeitung: 0.378 Sekunden
(vorverarbeitet am 2026-08-08)
¤ *© Formatika GbR, Deutschland
