#include "nodes/execnodes.h"

Include dependency graph for nodeModifyTable.h:

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

Functions
void	ExecInitGenerated (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 545 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)
            ExecInitGenerated(resultRelInfo, estate, cmdtype);
        if (resultRelInfo->ri_NumGeneratedNeededU == 0)
            return;
        ri_GeneratedExprs = resultRelInfo->ri_GeneratedExprsU;
    }
    else
    {
        if (resultRelInfo->ri_GeneratedExprsI == NULL)
            ExecInitGenerated(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_array(Datum, natts);
    nulls = palloc_array(bool, natts);
 
    slot_getallattrs(slot);
    memcpy(nulls, slot->tts_isnull, sizeof(*nulls) * natts);
 
    for (int i = 0; i < natts; i++)
    {
        CompactAttribute *attr = TupleDescCompactAttr(tupdesc, i);
 
        if (ri_GeneratedExprs[i])
        {
            Datum       val;
            bool        isnull;
 
            Assert(TupleDescAttr(tupdesc, i)->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(), CompactAttribute::attbyval, CompactAttribute::attlen, CMD_UPDATE, TupleDescData::constr, datumCopy(), ExprContext::ecxt_scantuple, ExecClearTuple(), ExecEvalExpr(), ExecInitGenerated(), ExecMaterializeSlot(), ExecStoreVirtualTuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, TupleConstr::has_generated_stored, i, MemoryContextSwitchTo(), TupleDescData::natts, palloc_array, 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(), TupleDescCompactAttr(), val, and values.

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

◆ ExecEndModifyTable()

void ExecEndModifyTable ( ModifyTableState * node )

Definition at line 5212 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);
    }
 
    /*
     * Terminate EPQ execution if active
     */
    EvalPlanQualEnd(&node->mt_epqstate);
 
    /*
     * shut down subplan
     */
    ExecEndNode(outerPlanState(node));
}

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

Referenced by ExecEndNode().

◆ ExecInitGenerated()

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

Definition at line 431 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 || 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 &&
        !(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++)
    {
        char        attgenerated = TupleDescAttr(tupdesc, i)->attgenerated;
 
        if (attgenerated)
        {
            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 */
            if (attgenerated == ATTRIBUTE_GENERATED_STORED)
            {
                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);
        }
    }
 
    if (ri_NumGeneratedNeeded == 0)
    {
        /* didn't need it after all */
        pfree(ri_GeneratedExprs);
        ri_GeneratedExprs = NULL;
    }
 
    /* 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;
 
        resultRelInfo->ri_extraUpdatedCols_valid = true;
    }
    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, TupleConstr::has_generated_virtual, i, MemoryContextSwitchTo(), TupleDescData::natts, palloc0(), pfree(), pull_varattnos(), RelationGetDescr, RelationGetRelationName, ResultRelInfo::ri_extraUpdatedCols, ResultRelInfo::ri_extraUpdatedCols_valid, 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().

◆ ExecInitMergeTupleSlots()

void ExecInitMergeTupleSlots	(	ModifyTableState *	mtstate,
		ResultRelInfo *	resultRelInfo
	)

Definition at line 3969 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 4637 of file nodeModifyTable.c.

{
    ModifyTableState *mtstate;
    Plan       *subplan = outerPlan(node);
    CmdType     operation = node->operation;
    int         total_nrels = list_length(node->resultRelations);
    int         nrels;
    List       *resultRelations = NIL;
    List       *withCheckOptionLists = NIL;
    List       *returningLists = NIL;
    List       *updateColnosLists = NIL;
    List       *mergeActionLists = NIL;
    List       *mergeJoinConditions = NIL;
    ResultRelInfo *resultRelInfo;
    List       *arowmarks;
    ListCell   *l;
    int         i;
    Relation    rel;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * 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.
     */
    i = 0;
    foreach(l, node->resultRelations)
    {
        Index       rti = lfirst_int(l);
        bool        keep_rel;
 
        keep_rel = bms_is_member(rti, estate->es_unpruned_relids);
        if (!keep_rel && i == total_nrels - 1 && resultRelations == NIL)
        {
            /* all result relations pruned; keep the first one */
            keep_rel = true;
            rti = linitial_int(node->resultRelations);
            i = 0;
        }
 
        if (keep_rel)
        {
            resultRelations = lappend_int(resultRelations, rti);
            if (node->withCheckOptionLists)
            {
                List       *withCheckOptions = list_nth_node(List,
                                                             node->withCheckOptionLists,
                                                             i);
 
                withCheckOptionLists = lappend(withCheckOptionLists, withCheckOptions);
            }
            if (node->returningLists)
            {
                List       *returningList = list_nth_node(List,
                                                          node->returningLists,
                                                          i);
 
                returningLists = lappend(returningLists, returningList);
            }
            if (node->updateColnosLists)
            {
                List       *updateColnosList = list_nth(node->updateColnosLists, i);
 
                updateColnosLists = lappend(updateColnosLists, updateColnosList);
            }
            if (node->mergeActionLists)
            {
                List       *mergeActionList = list_nth(node->mergeActionLists, i);
 
                mergeActionLists = lappend(mergeActionLists, mergeActionList);
            }
            if (node->mergeJoinConditions)
            {
                List       *mergeJoinCondition = list_nth(node->mergeJoinConditions, i);
 
                mergeJoinConditions = lappend(mergeJoinConditions, mergeJoinCondition);
            }
        }
        i++;
    }
    nrels = list_length(resultRelations);
    Assert(nrels > 0);
 
    /*
     * 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 = palloc_array(ResultRelInfo, nrels);
 
    mtstate->mt_merge_pending_not_matched = NULL;
    mtstate->mt_merge_inserted = 0;
    mtstate->mt_merge_updated = 0;
    mtstate->mt_merge_deleted = 0;
    mtstate->mt_updateColnosLists = updateColnosLists;
    mtstate->mt_mergeActionLists = mergeActionLists;
    mtstate->mt_mergeJoinConditions = mergeJoinConditions;
 
    /*----------
     * 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)
    {
        Assert(bms_is_member(node->rootRelation, estate->es_unpruned_relids));
        mtstate->rootResultRelInfo = makeNode(ResultRelInfo);
        ExecInitResultRelation(estate, mtstate->rootResultRelInfo,
                               node->rootRelation);
    }
    else
    {
        Assert(list_length(node->resultRelations) == 1);
        Assert(list_length(resultRelations) == 1);
        mtstate->rootResultRelInfo = mtstate->resultRelInfo;
        ExecInitResultRelation(estate, mtstate->resultRelInfo,
                               linitial_int(resultRelations));
    }
 
    /* set up epqstate with dummy subplan data for the moment */
    EvalPlanQualInit(&mtstate->mt_epqstate, estate, NULL, NIL,
                     node->epqParam, 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, resultRelations)
    {
        Index       resultRelation = lfirst_int(l);
        List       *mergeActions = NIL;
 
        if (mergeActionLists)
            mergeActions = list_nth(mergeActionLists, i);
 
        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, node->onConflictAction,
                            mergeActions);
 
        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
            {
                /* 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) || total_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, 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 (returningLists)
    {
        TupleTableSlot *slot;
        ExprContext *econtext;
 
        /*
         * 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.
         */
        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, 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?).
         */
        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(total_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, 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.
     */
    arowmarks = NIL;
    foreach(l, node->rowMarks)
    {
        PlanRowMark *rc = lfirst_node(PlanRowMark, l);
        ExecRowMark *erm;
        ExecAuxRowMark *aerm;
 
        /*
         * Ignore "parent" rowmarks, because they are irrelevant at runtime.
         * Also ignore the rowmarks belonging to child tables that have been
         * pruned in ExecDoInitialPruning().
         */
        if (rc->isParent ||
            !bms_is_member(rc->rti, estate->es_unpruned_relids))
            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(total_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().

◆ ExecReScanModifyTable()

void ExecReScanModifyTable ( ModifyTableState * node )

Definition at line 5266 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().