#include "nodes/execnodes.h"

Include dependency graph for nodeModifyTable.h:

This graph shows which files directly or indirectly include this file:

Functions
void	ExecInitStoredGenerated (ResultRelInfo resultRelInfo, EState estate, CmdType cmdtype)

void	ExecComputeStoredGenerated (ResultRelInfo resultRelInfo, EState estate, TupleTableSlot *slot, CmdType cmdtype)

ModifyTableState *	ExecInitModifyTable (ModifyTable node, EState estate, int eflags)

void	ExecEndModifyTable (ModifyTableState *node)

void	ExecReScanModifyTable (ModifyTableState *node)

void	ExecInitMergeTupleSlots (ModifyTableState mtstate, ResultRelInfo resultRelInfo)

Function Documentation

◆ ExecComputeStoredGenerated()

void ExecComputeStoredGenerated	(	ResultRelInfo *	resultRelInfo,
		EState *	estate,
		TupleTableSlot *	slot,
		CmdType	cmdtype
	)

Definition at line 446 of file nodeModifyTable.c.

 {
     Relation    rel = resultRelInfo->ri_RelationDesc;
     TupleDesc   tupdesc = RelationGetDescr(rel);
     int         natts = tupdesc->natts;
     ExprContext *econtext = GetPerTupleExprContext(estate);
     ExprState **ri_GeneratedExprs;
     MemoryContext oldContext;
     Datum      *values;
     bool       *nulls;
  
     /* We should not be called unless this is true */
     Assert(tupdesc->constr && tupdesc->constr->has_generated_stored);
  
     /*
      * 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)
             ExecInitStoredGenerated(resultRelInfo, estate, cmdtype);
         if (resultRelInfo->ri_NumGeneratedNeededU == 0)
             return;
         ri_GeneratedExprs = resultRelInfo->ri_GeneratedExprsU;
     }
     else
     {
         if (resultRelInfo->ri_GeneratedExprsI == NULL)
             ExecInitStoredGenerated(resultRelInfo, estate, cmdtype);
         /* Early exit is impossible given the prior Assert */
         Assert(resultRelInfo->ri_NumGeneratedNeededI > 0);
         ri_GeneratedExprs = resultRelInfo->ri_GeneratedExprsI;
     }
  
     oldContext = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
     values = palloc(sizeof(*values) * natts);
     nulls = palloc(sizeof(*nulls) * natts);
  
     slot_getallattrs(slot);
     memcpy(nulls, slot->tts_isnull, sizeof(*nulls) * natts);
  
     for (int i = 0; i < natts; i++)
     {
         Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
  
         if (ri_GeneratedExprs[i])
         {
             Datum       val;
             bool        isnull;
  
             Assert(attr->attgenerated == ATTRIBUTE_GENERATED_STORED);
  
             econtext->ecxt_scantuple = slot;
  
             val = ExecEvalExpr(ri_GeneratedExprs[i], econtext, &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)
                 val = datumCopy(val, attr->attbyval, attr->attlen);
  
             values[i] = val;
             nulls[i] = isnull;
         }
         else
         {
             if (!nulls[i])
                 values[i] = datumCopy(slot->tts_values[i], attr->attbyval, attr->attlen);
         }
     }
  
     ExecClearTuple(slot);
     memcpy(slot->tts_values, values, sizeof(*values) * natts);
     memcpy(slot->tts_isnull, nulls, sizeof(*nulls) * natts);
     ExecStoreVirtualTuple(slot);
     ExecMaterializeSlot(slot);
  
     MemoryContextSwitchTo(oldContext);
 }

References Assert(), CMD_UPDATE, TupleDescData::constr, datumCopy(), ExprContext::ecxt_scantuple, ExecClearTuple(), ExecEvalExpr(), ExecInitStoredGenerated(), ExecMaterializeSlot(), ExecStoreVirtualTuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, TupleConstr::has_generated_stored, i, MemoryContextSwitchTo(), TupleDescData::natts, palloc(), RelationGetDescr, ResultRelInfo::ri_GeneratedExprsI, ResultRelInfo::ri_GeneratedExprsU, ResultRelInfo::ri_NumGeneratedNeededI, ResultRelInfo::ri_NumGeneratedNeededU, ResultRelInfo::ri_RelationDesc, slot_getallattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, TupleDescAttr, val, and values.

Referenced by CopyFrom(), ExecInsert(), ExecSimpleRelationInsert(), ExecSimpleRelationUpdate(), and ExecUpdatePrepareSlot().

◆ ExecEndModifyTable()

void ExecEndModifyTable ( ModifyTableState * node )

Definition at line 4406 of file nodeModifyTable.c.

 {
     int         i;
  
     /*
      * Allow any FDWs to shut down
      */
     for (i = 0; i < node->mt_nrels; i++)
     {
         int         j;
         ResultRelInfo *resultRelInfo = node->resultRelInfo + i;
  
         if (!resultRelInfo->ri_usesFdwDirectModify &&
             resultRelInfo->ri_FdwRoutine != NULL &&
             resultRelInfo->ri_FdwRoutine->EndForeignModify != NULL)
             resultRelInfo->ri_FdwRoutine->EndForeignModify(node->ps.state,
                                                            resultRelInfo);
  
         /*
          * 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++)
         {
             ExecDropSingleTupleTableSlot(resultRelInfo->ri_Slots[j]);
             ExecDropSingleTupleTableSlot(resultRelInfo->ri_PlanSlots[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)
     {
         ExecCleanupTupleRouting(node, node->mt_partition_tuple_routing);
  
         if (node->mt_root_tuple_slot)
             ExecDropSingleTupleTableSlot(node->mt_root_tuple_slot);
     }
  
     /*
      * Free the exprcontext
      */
     ExecFreeExprContext(&node->ps);
  
     /*
      * clean out the tuple table
      */
     if (node->ps.ps_ResultTupleSlot)
         ExecClearTuple(node->ps.ps_ResultTupleSlot);
  
     /*
      * Terminate EPQ execution if active
      */
     EvalPlanQualEnd(&node->mt_epqstate);
  
     /*
      * shut down subplan
      */
     ExecEndNode(outerPlanState(node));
 }

References FdwRoutine::EndForeignModify, EvalPlanQualEnd(), ExecCleanupTupleRouting(), ExecClearTuple(), ExecDropSingleTupleTableSlot(), ExecEndNode(), ExecFreeExprContext(), i, j, ModifyTableState::mt_epqstate, ModifyTableState::mt_nrels, ModifyTableState::mt_partition_tuple_routing, ModifyTableState::mt_root_tuple_slot, outerPlanState, ModifyTableState::ps, PlanState::ps_ResultTupleSlot, ModifyTableState::resultRelInfo, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_NumSlotsInitialized, ResultRelInfo::ri_PlanSlots, ResultRelInfo::ri_Slots, ResultRelInfo::ri_usesFdwDirectModify, and PlanState::state.

Referenced by ExecEndNode().

◆ ExecInitMergeTupleSlots()

void ExecInitMergeTupleSlots	(	ModifyTableState *	mtstate,
		ResultRelInfo *	resultRelInfo
	)

Definition at line 3347 of file nodeModifyTable.c.

 {
     EState     *estate = mtstate->ps.state;
  
     Assert(!resultRelInfo->ri_projectNewInfoValid);
  
     resultRelInfo->ri_oldTupleSlot =
         table_slot_create(resultRelInfo->ri_RelationDesc,
                           &estate->es_tupleTable);
     resultRelInfo->ri_newTupleSlot =
         table_slot_create(resultRelInfo->ri_RelationDesc,
                           &estate->es_tupleTable);
     resultRelInfo->ri_projectNewInfoValid = true;
 }

References Assert(), EState::es_tupleTable, ModifyTableState::ps, ResultRelInfo::ri_newTupleSlot, ResultRelInfo::ri_oldTupleSlot, ResultRelInfo::ri_projectNewInfoValid, ResultRelInfo::ri_RelationDesc, PlanState::state, and table_slot_create().

Referenced by ExecInitMerge(), and ExecInitPartitionInfo().

◆ ExecInitModifyTable()

ModifyTableState* ExecInitModifyTable	(	ModifyTable *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 3925 of file nodeModifyTable.c.

 {
     ModifyTableState *mtstate;
     Plan       *subplan = outerPlan(node);
     CmdType     operation = node->operation;
     int         nrels = list_length(node->resultRelations);
     ResultRelInfo *resultRelInfo;
     List       *arowmarks;
     ListCell   *l;
     int         i;
     Relation    rel;
  
     /* check for unsupported flags */
     Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
  
     /*
      * create state structure
      */
     mtstate = makeNode(ModifyTableState);
     mtstate->ps.plan = (Plan *) node;
     mtstate->ps.state = estate;
     mtstate->ps.ExecProcNode = ExecModifyTable;
  
     mtstate->operation = operation;
     mtstate->canSetTag = node->canSetTag;
     mtstate->mt_done = false;
  
     mtstate->mt_nrels = nrels;
     mtstate->resultRelInfo = (ResultRelInfo *)
         palloc(nrels * sizeof(ResultRelInfo));
  
     mtstate->mt_merge_inserted = 0;
     mtstate->mt_merge_updated = 0;
     mtstate->mt_merge_deleted = 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 table, the root partition doesn't appear
      * elsewhere in the plan and its RT index is given explicitly in
      * node->rootRelation.  Otherwise (i.e. table inheritance) the target
      * relation is the first relation in the node->resultRelations list.
      *----------
      */
     if (node->rootRelation > 0)
     {
         mtstate->rootResultRelInfo = makeNode(ResultRelInfo);
         ExecInitResultRelation(estate, mtstate->rootResultRelInfo,
                                node->rootRelation);
     }
     else
     {
         mtstate->rootResultRelInfo = mtstate->resultRelInfo;
         ExecInitResultRelation(estate, mtstate->resultRelInfo,
                                linitial_int(node->resultRelations));
     }
  
     /* set up epqstate with dummy subplan data for the moment */
     EvalPlanQualInit(&mtstate->mt_epqstate, estate, NULL, NIL,
                      node->epqParam, node->resultRelations);
     mtstate->fireBSTriggers = 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))
         ExecSetupTransitionCaptureState(mtstate, estate);
  
     /*
      * 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.
      */
     resultRelInfo = mtstate->resultRelInfo;
     i = 0;
     foreach(l, node->resultRelations)
     {
         Index       resultRelation = lfirst_int(l);
  
         if (resultRelInfo != mtstate->rootResultRelInfo)
         {
             ExecInitResultRelation(estate, resultRelInfo, resultRelation);
  
             /*
              * 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.
              */
             resultRelInfo->ri_RootResultRelInfo = mtstate->rootResultRelInfo;
         }
  
         /* Initialize the usesFdwDirectModify flag */
         resultRelInfo->ri_usesFdwDirectModify =
             bms_is_member(i, node->fdwDirectModifyPlans);
  
         /*
          * Verify result relation is a valid target for the current operation
          */
         CheckValidResultRel(resultRelInfo, operation);
  
         resultRelInfo++;
         i++;
     }
  
     /*
      * Now we may initialize the subplan.
      */
     outerPlanState(mtstate) = ExecInitNode(subplan, estate, eflags);
  
     /*
      * Do additional per-result-relation initialization.
      */
     for (i = 0; i < nrels; i++)
     {
         resultRelInfo = &mtstate->resultRelInfo[i];
  
         /* Let FDWs init themselves for foreign-table result rels */
         if (!resultRelInfo->ri_usesFdwDirectModify &&
             resultRelInfo->ri_FdwRoutine != NULL &&
             resultRelInfo->ri_FdwRoutine->BeginForeignModify != NULL)
         {
             List       *fdw_private = (List *) list_nth(node->fdwPrivLists, i);
  
             resultRelInfo->ri_FdwRoutine->BeginForeignModify(mtstate,
                                                              resultRelInfo,
                                                              fdw_private,
                                                              i,
                                                              eflags);
         }
  
         /*
          * 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 ||
             operation == CMD_MERGE)
         {
             char        relkind;
  
             relkind = resultRelInfo->ri_RelationDesc->rd_rel->relkind;
             if (relkind == RELKIND_RELATION ||
                 relkind == RELKIND_MATVIEW ||
                 relkind == RELKIND_PARTITIONED_TABLE)
             {
                 resultRelInfo->ri_RowIdAttNo =
                     ExecFindJunkAttributeInTlist(subplan->targetlist, "ctid");
                 if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
                     elog(ERROR, "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.)
                  */
                 Assert(operation != CMD_MERGE);
  
                 /*
                  * 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.
                  */
                 resultRelInfo->ri_RowIdAttNo =
                     ExecFindJunkAttributeInTlist(subplan->targetlist,
                                                  "wholerow");
                 if ((mtstate->operation == CMD_UPDATE || mtstate->operation == CMD_MERGE) &&
                     !AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
                     elog(ERROR, "could not find junk wholerow column");
             }
             else
             {
                 /* No support for MERGE */
                 Assert(operation != CMD_MERGE);
                 /* Other valid target relkinds must provide wholerow */
                 resultRelInfo->ri_RowIdAttNo =
                     ExecFindJunkAttributeInTlist(subplan->targetlist,
                                                  "wholerow");
                 if (!AttributeNumberIsValid(resultRelInfo->ri_RowIdAttNo))
                     elog(ERROR, "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.
      */
     mtstate->mt_resultOidAttno =
         ExecFindJunkAttributeInTlist(subplan->targetlist, "tableoid");
     Assert(AttributeNumberIsValid(mtstate->mt_resultOidAttno) || nrels == 1);
     mtstate->mt_lastResultOid = InvalidOid; /* force lookup at first tuple */
     mtstate->mt_lastResultIndex = 0;    /* must be zero if no such attr */
  
     /* Get the root target relation */
     rel = mtstate->rootResultRelInfo->ri_RelationDesc;
  
     /*
      * 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 &&
         operation == CMD_INSERT)
         mtstate->mt_partition_tuple_routing =
             ExecSetupPartitionTupleRouting(estate, rel);
  
     /*
      * Initialize any WITH CHECK OPTION constraints if needed.
      */
     resultRelInfo = mtstate->resultRelInfo;
     foreach(l, node->withCheckOptionLists)
     {
         List       *wcoList = (List *) lfirst(l);
         List       *wcoExprs = NIL;
         ListCell   *ll;
  
         foreach(ll, wcoList)
         {
             WithCheckOption *wco = (WithCheckOption *) lfirst(ll);
             ExprState  *wcoExpr = ExecInitQual((List *) wco->qual,
                                                &mtstate->ps);
  
             wcoExprs = lappend(wcoExprs, wcoExpr);
         }
  
         resultRelInfo->ri_WithCheckOptions = wcoList;
         resultRelInfo->ri_WithCheckOptionExprs = wcoExprs;
         resultRelInfo++;
     }
  
     /*
      * Initialize RETURNING projections if needed.
      */
     if (node->returningLists)
     {
         TupleTableSlot *slot;
         ExprContext *econtext;
  
         /*
          * Initialize result tuple slot and assign its rowtype using the first
          * RETURNING list.  We assume the rest will look the same.
          */
         mtstate->ps.plan->targetlist = (List *) linitial(node->returningLists);
  
         /* Set up a slot for the output of the RETURNING projection(s) */
         ExecInitResultTupleSlotTL(&mtstate->ps, &TTSOpsVirtual);
         slot = mtstate->ps.ps_ResultTupleSlot;
  
         /* Need an econtext too */
         if (mtstate->ps.ps_ExprContext == NULL)
             ExecAssignExprContext(estate, &mtstate->ps);
         econtext = mtstate->ps.ps_ExprContext;
  
         /*
          * Build a projection for each result rel.
          */
         resultRelInfo = mtstate->resultRelInfo;
         foreach(l, node->returningLists)
         {
             List       *rlist = (List *) lfirst(l);
  
             resultRelInfo->ri_returningList = rlist;
             resultRelInfo->ri_projectReturning =
                 ExecBuildProjectionInfo(rlist, econtext, slot, &mtstate->ps,
                                         resultRelInfo->ri_RelationDesc->rd_att);
             resultRelInfo++;
         }
     }
     else
     {
         /*
          * We still must construct a dummy result tuple type, because InitPlan
          * expects one (maybe should change that?).
          */
         mtstate->ps.plan->targetlist = NIL;
         ExecInitResultTypeTL(&mtstate->ps);
  
         mtstate->ps.ps_ExprContext = NULL;
     }
  
     /* Set the list of arbiter indexes if needed for ON CONFLICT */
     resultRelInfo = mtstate->resultRelInfo;
     if (node->onConflictAction != ONCONFLICT_NONE)
     {
         /* insert may only have one relation, inheritance is not expanded */
         Assert(nrels == 1);
         resultRelInfo->ri_onConflictArbiterIndexes = node->arbiterIndexes;
     }
  
     /*
      * If needed, Initialize target list, projection and qual for ON CONFLICT
      * DO UPDATE.
      */
     if (node->onConflictAction == ONCONFLICT_UPDATE)
     {
         OnConflictSetState *onconfl = makeNode(OnConflictSetState);
         ExprContext *econtext;
         TupleDesc   relationDesc;
  
         /* already exists if created by RETURNING processing above */
         if (mtstate->ps.ps_ExprContext == NULL)
             ExecAssignExprContext(estate, &mtstate->ps);
  
         econtext = mtstate->ps.ps_ExprContext;
         relationDesc = resultRelInfo->ri_RelationDesc->rd_att;
  
         /* create state for DO UPDATE SET operation */
         resultRelInfo->ri_onConflict = onconfl;
  
         /* initialize slot for the existing tuple */
         onconfl->oc_Existing =
             table_slot_create(resultRelInfo->ri_RelationDesc,
                               &mtstate->ps.state->es_tupleTable);
  
         /*
          * 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.
          */
         onconfl->oc_ProjSlot =
             table_slot_create(resultRelInfo->ri_RelationDesc,
                               &mtstate->ps.state->es_tupleTable);
  
         /* build UPDATE SET projection state */
         onconfl->oc_ProjInfo =
             ExecBuildUpdateProjection(node->onConflictSet,
                                       true,
                                       node->onConflictCols,
                                       relationDesc,
                                       econtext,
                                       onconfl->oc_ProjSlot,
                                       &mtstate->ps);
  
         /* initialize state to evaluate the WHERE clause, if any */
         if (node->onConflictWhere)
         {
             ExprState  *qualexpr;
  
             qualexpr = ExecInitQual((List *) node->onConflictWhere,
                                     &mtstate->ps);
             onconfl->oc_WhereClause = qualexpr;
         }
     }
  
     /*
      * If we have any secondary relations in an UPDATE or DELETE, they need to
      * be treated like non-locked relations in SELECT FOR UPDATE, ie, the
      * EvalPlanQual mechanism needs to be told about them.  Locate the
      * relevant ExecRowMarks.
      */
     arowmarks = NIL;
     foreach(l, node->rowMarks)
     {
         PlanRowMark *rc = lfirst_node(PlanRowMark, l);
         ExecRowMark *erm;
         ExecAuxRowMark *aerm;
  
         /* ignore "parent" rowmarks; they are irrelevant at runtime */
         if (rc->isParent)
             continue;
  
         /* Find ExecRowMark and build ExecAuxRowMark */
         erm = ExecFindRowMark(estate, rc->rti, false);
         aerm = ExecBuildAuxRowMark(erm, subplan->targetlist);
         arowmarks = lappend(arowmarks, aerm);
     }
  
     /* For a MERGE command, initialize its state */
     if (mtstate->operation == CMD_MERGE)
         ExecInitMerge(mtstate, estate);
  
     EvalPlanQualSetPlan(&mtstate->mt_epqstate, subplan, arowmarks);
  
     /*
      * 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)
     {
         HASHCTL     hash_ctl;
  
         hash_ctl.keysize = sizeof(Oid);
         hash_ctl.entrysize = sizeof(MTTargetRelLookup);
         hash_ctl.hcxt = CurrentMemoryContext;
         mtstate->mt_resultOidHash =
             hash_create("ModifyTable target hash",
                         nrels, &hash_ctl,
                         HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
         for (i = 0; i < nrels; i++)
         {
             Oid         hashkey;
             MTTargetRelLookup *mtlookup;
             bool        found;
  
             resultRelInfo = &mtstate->resultRelInfo[i];
             hashkey = RelationGetRelid(resultRelInfo->ri_RelationDesc);
             mtlookup = (MTTargetRelLookup *)
                 hash_search(mtstate->mt_resultOidHash, &hashkey,
                             HASH_ENTER, &found);
             Assert(!found);
             mtlookup->relationIndex = i;
         }
     }
     else
         mtstate->mt_resultOidHash = NULL;
  
     /*
      * 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 */
         Assert(nrels == 1);
         resultRelInfo = mtstate->resultRelInfo;
         if (!resultRelInfo->ri_usesFdwDirectModify &&
             resultRelInfo->ri_FdwRoutine != NULL &&
             resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize &&
             resultRelInfo->ri_FdwRoutine->ExecForeignBatchInsert)
         {
             resultRelInfo->ri_BatchSize =
                 resultRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize(resultRelInfo);
             Assert(resultRelInfo->ri_BatchSize >= 1);
         }
         else
             resultRelInfo->ri_BatchSize = 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)
         estate->es_auxmodifytables = lcons(mtstate,
                                            estate->es_auxmodifytables);
  
     return mtstate;
 }

Referenced by ExecInitNode().

◆ ExecInitStoredGenerated()

void ExecInitStoredGenerated	(	ResultRelInfo *	resultRelInfo,
		EState *	estate,
		CmdType	cmdtype
	)

Definition at line 346 of file nodeModifyTable.c.

 {
     Relation    rel = resultRelInfo->ri_RelationDesc;
     TupleDesc   tupdesc = RelationGetDescr(rel);
     int         natts = tupdesc->natts;
     ExprState **ri_GeneratedExprs;
     int         ri_NumGeneratedNeeded;
     Bitmapset  *updatedCols;
     MemoryContext oldContext;
  
     /* Nothing to do if no generated columns */
     if (!(tupdesc->constr && tupdesc->constr->has_generated_stored))
         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 &&
         !(rel->trigdesc && rel->trigdesc->trig_update_before_row))
         updatedCols = ExecGetUpdatedCols(resultRelInfo, estate);
     else
         updatedCols = NULL;
  
     /*
      * Make sure these data structures are built in the per-query memory
      * context so they'll survive throughout the query.
      */
     oldContext = MemoryContextSwitchTo(estate->es_query_cxt);
  
     ri_GeneratedExprs = (ExprState **) palloc0(natts * sizeof(ExprState *));
     ri_NumGeneratedNeeded = 0;
  
     for (int i = 0; i < natts; i++)
     {
         if (TupleDescAttr(tupdesc, i)->attgenerated == ATTRIBUTE_GENERATED_STORED)
         {
             Expr       *expr;
  
             /* Fetch the GENERATED AS expression tree */
             expr = (Expr *) build_column_default(rel, i + 1);
             if (expr == NULL)
                 elog(ERROR, "no generation expression found for column number %d of table \"%s\"",
                      i + 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)
             {
                 Bitmapset  *attrs_used = NULL;
  
                 pull_varattnos((Node *) expr, 1, &attrs_used);
  
                 if (!bms_overlap(updatedCols, attrs_used))
                     continue;   /* need not update this column */
             }
  
             /* No luck, so prepare the expression for execution */
             ri_GeneratedExprs[i] = ExecPrepareExpr(expr, estate);
             ri_NumGeneratedNeeded++;
  
             /* If UPDATE, mark column in resultRelInfo->ri_extraUpdatedCols */
             if (cmdtype == CMD_UPDATE)
                 resultRelInfo->ri_extraUpdatedCols =
                     bms_add_member(resultRelInfo->ri_extraUpdatedCols,
                                    i + 1 - FirstLowInvalidHeapAttributeNumber);
         }
     }
  
     /* Save in appropriate set of fields */
     if (cmdtype == CMD_UPDATE)
     {
         /* Don't call twice */
         Assert(resultRelInfo->ri_GeneratedExprsU == NULL);
  
         resultRelInfo->ri_GeneratedExprsU = ri_GeneratedExprs;
         resultRelInfo->ri_NumGeneratedNeededU = ri_NumGeneratedNeeded;
     }
     else
     {
         /* Don't call twice */
         Assert(resultRelInfo->ri_GeneratedExprsI == NULL);
  
         resultRelInfo->ri_GeneratedExprsI = ri_GeneratedExprs;
         resultRelInfo->ri_NumGeneratedNeededI = ri_NumGeneratedNeeded;
     }
  
     MemoryContextSwitchTo(oldContext);
 }

References Assert(), bms_add_member(), bms_overlap(), build_column_default(), CMD_UPDATE, TupleDescData::constr, elog(), ERROR, EState::es_query_cxt, ExecGetUpdatedCols(), ExecPrepareExpr(), FirstLowInvalidHeapAttributeNumber, TupleConstr::has_generated_stored, i, MemoryContextSwitchTo(), TupleDescData::natts, palloc0(), pull_varattnos(), RelationGetDescr, RelationGetRelationName, ResultRelInfo::ri_extraUpdatedCols, ResultRelInfo::ri_GeneratedExprsI, ResultRelInfo::ri_GeneratedExprsU, ResultRelInfo::ri_NumGeneratedNeededI, ResultRelInfo::ri_NumGeneratedNeededU, ResultRelInfo::ri_RelationDesc, TriggerDesc::trig_update_before_row, RelationData::trigdesc, and TupleDescAttr.

Referenced by ExecComputeStoredGenerated(), and ExecGetExtraUpdatedCols().

◆ ExecReScanModifyTable()

void ExecReScanModifyTable ( ModifyTableState * node )

Definition at line 4471 of file nodeModifyTable.c.

 {
     /*
      * Currently, we don't need to support rescan on ModifyTable nodes. The
      * semantics of that would be a bit debatable anyway.
      */
     elog(ERROR, "ExecReScanModifyTable is not implemented");
 }

References elog(), and ERROR.

Referenced by ExecReScan().