execPartition.h File Reference

#include "nodes/execnodes.h"
#include "nodes/parsenodes.h"
#include "nodes/plannodes.h"
#include "partitioning/partprune.h"

Include dependency graph for execPartition.h:

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

Go to the source code of this file.

Data Structures
struct	PartitionedRelPruningData
struct	PartitionPruningData
struct	PartitionPruneState

Typedefs
typedef struct PartitionDispatchData *	PartitionDispatch
typedef struct PartitionTupleRouting	PartitionTupleRouting
typedef struct PartitionedRelPruningData	PartitionedRelPruningData
typedef struct PartitionPruningData	PartitionPruningData
typedef struct PartitionPruneState	PartitionPruneState

Functions
PartitionTupleRouting *	ExecSetupPartitionTupleRouting (EState *estate, Relation rel)
ResultRelInfo *	ExecFindPartition (ModifyTableState *mtstate, ResultRelInfo *rootResultRelInfo, PartitionTupleRouting *proute, TupleTableSlot *slot, EState *estate)
void	ExecCleanupTupleRouting (ModifyTableState *mtstate, PartitionTupleRouting *proute)
PartitionPruneState *	ExecCreatePartitionPruneState (PlanState *planstate, PartitionPruneInfo *partitionpruneinfo)
Bitmapset *	ExecFindMatchingSubPlans (PartitionPruneState *prunestate)
Bitmapset *	ExecFindInitialMatchingSubPlans (PartitionPruneState *prunestate, int nsubplans)

Typedef Documentation

PartitionDispatch

typedef struct PartitionDispatchData* PartitionDispatch

Definition at line 22 of file execPartition.h.

PartitionedRelPruningData

typedef struct PartitionedRelPruningData PartitionedRelPruningData

PartitionPruneState

typedef struct PartitionPruneState PartitionPruneState

PartitionPruningData

typedef struct PartitionPruningData PartitionPruningData

PartitionTupleRouting

typedef struct PartitionTupleRouting PartitionTupleRouting

Definition at line 23 of file execPartition.h.

Function Documentation

ExecCleanupTupleRouting()

void ExecCleanupTupleRouting	(	ModifyTableState *	mtstate,
		PartitionTupleRouting *	proute
	)

Definition at line 1124 of file execPartition.c.

References FdwRoutine::EndForeignInsert, ExecCloseIndices(), ExecDropSingleTupleTableSlot(), i, PartitionTupleRouting::is_borrowed_rel, NoLock, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, PartitionTupleRouting::partition_dispatch_info, PartitionTupleRouting::partitions, ModifyTableState::ps, PartitionDispatchData::reldesc, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_RelationDesc, PlanState::state, table_close(), and PartitionDispatchData::tupslot.

Referenced by CopyFrom(), ExecEndModifyTable(), and finish_edata().

{
    int         i;

    /*
     * Remember, proute->partition_dispatch_info[0] corresponds to the root
     * partitioned table, which we must not try to close, because it is the
     * main target table of the query that will be closed by callers such as
     * ExecEndPlan() or DoCopy(). Also, tupslot is NULL for the root
     * partitioned table.
     */
    for (i = 1; i < proute->num_dispatch; i++)
    {
        PartitionDispatch pd = proute->partition_dispatch_info[i];

        table_close(pd->reldesc, NoLock);

        if (pd->tupslot)
            ExecDropSingleTupleTableSlot(pd->tupslot);
    }

    for (i = 0; i < proute->num_partitions; i++)
    {
        ResultRelInfo *resultRelInfo = proute->partitions[i];

        /* Allow any FDWs to shut down */
        if (resultRelInfo->ri_FdwRoutine != NULL &&
            resultRelInfo->ri_FdwRoutine->EndForeignInsert != NULL)
            resultRelInfo->ri_FdwRoutine->EndForeignInsert(mtstate->ps.state,
                                                           resultRelInfo);

        /*
         * Close it if it's not one of the result relations borrowed from the
         * owning ModifyTableState; those will be closed by ExecEndPlan().
         */
        if (proute->is_borrowed_rel[i])
            continue;

        ExecCloseIndices(resultRelInfo);
        table_close(resultRelInfo->ri_RelationDesc, NoLock);
    }
}

ExecCreatePartitionPruneState()

PartitionPruneState* ExecCreatePartitionPruneState	(	PlanState *	planstate,
		PartitionPruneInfo *	partitionpruneinfo
	)

Definition at line 1531 of file execPartition.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, bms_add_members(), bms_copy(), CreatePartitionDirectory(), CurrentMemoryContext, PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, elog, ERROR, EState::es_partition_directory, EState::es_query_cxt, PartitionedRelPruningData::exec_context, PartitionedRelPruningData::exec_pruning_steps, PartitionedRelPruneInfo::exec_pruning_steps, ExecGetRangeTableRelation(), ExecInitPruningContext(), PartitionPruneState::execparamids, PartitionedRelPruneInfo::execparamids, i, PartitionedRelPruningData::initial_context, PartitionedRelPruningData::initial_pruning_steps, PartitionedRelPruneInfo::initial_pruning_steps, lfirst_node, list_length(), PartitionDescData::nparts, PartitionedRelPruningData::nparts, PartitionedRelPruneInfo::nparts, PartitionPruneState::num_partprunedata, PartitionPruningData::num_partrelprunedata, offsetof, OidIsValid, PartitionDescData::oids, PartitionPruneState::other_subplans, PartitionPruneInfo::other_subplans, palloc(), PartitionDirectoryLookup(), PartitionPruneState::partprunedata, PartitionPruningData::partrelprunedata, PartitionedRelPruningData::present_parts, PartitionedRelPruneInfo::present_parts, PartitionPruneState::prune_context, PartitionPruneInfo::prune_infos, RelationGetPartitionKey(), PartitionedRelPruneInfo::relid_map, PartitionedRelPruneInfo::rtindex, PlanState::state, PartitionedRelPruningData::subpart_map, PartitionedRelPruneInfo::subpart_map, PartitionedRelPruningData::subplan_map, and PartitionedRelPruneInfo::subplan_map.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

{
    EState     *estate = planstate->state;
    PartitionPruneState *prunestate;
    int         n_part_hierarchies;
    ListCell   *lc;
    int         i;

    /* For data reading, executor always omits detached partitions */
    if (estate->es_partition_directory == NULL)
        estate->es_partition_directory =
            CreatePartitionDirectory(estate->es_query_cxt, false);

    n_part_hierarchies = list_length(partitionpruneinfo->prune_infos);
    Assert(n_part_hierarchies > 0);

    /*
     * Allocate the data structure
     */
    prunestate = (PartitionPruneState *)
        palloc(offsetof(PartitionPruneState, partprunedata) +
               sizeof(PartitionPruningData *) * n_part_hierarchies);

    prunestate->execparamids = NULL;
    /* other_subplans can change at runtime, so we need our own copy */
    prunestate->other_subplans = bms_copy(partitionpruneinfo->other_subplans);
    prunestate->do_initial_prune = false;   /* may be set below */
    prunestate->do_exec_prune = false;  /* may be set below */
    prunestate->num_partprunedata = n_part_hierarchies;

    /*
     * Create a short-term memory context which we'll use when making calls to
     * the partition pruning functions.  This avoids possible memory leaks,
     * since the pruning functions call comparison functions that aren't under
     * our control.
     */
    prunestate->prune_context =
        AllocSetContextCreate(CurrentMemoryContext,
                              "Partition Prune",
                              ALLOCSET_DEFAULT_SIZES);

    i = 0;
    foreach(lc, partitionpruneinfo->prune_infos)
    {
        List       *partrelpruneinfos = lfirst_node(List, lc);
        int         npartrelpruneinfos = list_length(partrelpruneinfos);
        PartitionPruningData *prunedata;
        ListCell   *lc2;
        int         j;

        prunedata = (PartitionPruningData *)
            palloc(offsetof(PartitionPruningData, partrelprunedata) +
                   npartrelpruneinfos * sizeof(PartitionedRelPruningData));
        prunestate->partprunedata[i] = prunedata;
        prunedata->num_partrelprunedata = npartrelpruneinfos;

        j = 0;
        foreach(lc2, partrelpruneinfos)
        {
            PartitionedRelPruneInfo *pinfo = lfirst_node(PartitionedRelPruneInfo, lc2);
            PartitionedRelPruningData *pprune = &prunedata->partrelprunedata[j];
            Relation    partrel;
            PartitionDesc partdesc;
            PartitionKey partkey;

            /*
             * We can rely on the copies of the partitioned table's partition
             * key and partition descriptor appearing in its relcache entry,
             * because that entry will be held open and locked for the
             * duration of this executor run.
             */
            partrel = ExecGetRangeTableRelation(estate, pinfo->rtindex);
            partkey = RelationGetPartitionKey(partrel);
            partdesc = PartitionDirectoryLookup(estate->es_partition_directory,
                                                partrel);

            /*
             * Initialize the subplan_map and subpart_map.
             *
             * Because we request detached partitions to be included, and
             * detaching waits for old transactions, it is safe to assume that
             * no partitions have disappeared since this query was planned.
             *
             * However, new partitions may have been added.
             */
            Assert(partdesc->nparts >= pinfo->nparts);
            pprune->nparts = partdesc->nparts;
            pprune->subplan_map = palloc(sizeof(int) * partdesc->nparts);
            if (partdesc->nparts == pinfo->nparts)
            {
                /*
                 * There are no new partitions, so this is simple.  We can
                 * simply point to the subpart_map from the plan, but we must
                 * copy the subplan_map since we may change it later.
                 */
                pprune->subpart_map = pinfo->subpart_map;
                memcpy(pprune->subplan_map, pinfo->subplan_map,
                       sizeof(int) * pinfo->nparts);

                /*
                 * Double-check that the list of unpruned relations has not
                 * changed.  (Pruned partitions are not in relid_map[].)
                 */
#ifdef USE_ASSERT_CHECKING
                for (int k = 0; k < pinfo->nparts; k++)
                {
                    Assert(partdesc->oids[k] == pinfo->relid_map[k] ||
                           pinfo->subplan_map[k] == -1);
                }
#endif
            }
            else
            {
                int         pd_idx = 0;
                int         pp_idx;

                /*
                 * Some new partitions have appeared since plan time, and
                 * those are reflected in our PartitionDesc but were not
                 * present in the one used to construct subplan_map and
                 * subpart_map.  So we must construct new and longer arrays
                 * where the partitions that were originally present map to
                 * the same sub-structures, and any added partitions map to
                 * -1, as if the new partitions had been pruned.
                 *
                 * Note: pinfo->relid_map[] may contain InvalidOid entries for
                 * partitions pruned by the planner.  We cannot tell exactly
                 * which of the partdesc entries these correspond to, but we
                 * don't have to; just skip over them.  The non-pruned
                 * relid_map entries, however, had better be a subset of the
                 * partdesc entries and in the same order.
                 */
                pprune->subpart_map = palloc(sizeof(int) * partdesc->nparts);
                for (pp_idx = 0; pp_idx < partdesc->nparts; pp_idx++)
                {
                    /* Skip any InvalidOid relid_map entries */
                    while (pd_idx < pinfo->nparts &&
                           !OidIsValid(pinfo->relid_map[pd_idx]))
                        pd_idx++;

                    if (pd_idx < pinfo->nparts &&
                        pinfo->relid_map[pd_idx] == partdesc->oids[pp_idx])
                    {
                        /* match... */
                        pprune->subplan_map[pp_idx] =
                            pinfo->subplan_map[pd_idx];
                        pprune->subpart_map[pp_idx] =
                            pinfo->subpart_map[pd_idx];
                        pd_idx++;
                    }
                    else
                    {
                        /* this partdesc entry is not in the plan */
                        pprune->subplan_map[pp_idx] = -1;
                        pprune->subpart_map[pp_idx] = -1;
                    }
                }

                /*
                 * It might seem that we need to skip any trailing InvalidOid
                 * entries in pinfo->relid_map before checking that we scanned
                 * all of the relid_map.  But we will have skipped them above,
                 * because they must correspond to some partdesc->oids
                 * entries; we just couldn't tell which.
                 */
                if (pd_idx != pinfo->nparts)
                    elog(ERROR, "could not match partition child tables to plan elements");
            }

            /* present_parts is also subject to later modification */
            pprune->present_parts = bms_copy(pinfo->present_parts);

            /*
             * Initialize pruning contexts as needed.
             */
            pprune->initial_pruning_steps = pinfo->initial_pruning_steps;
            if (pinfo->initial_pruning_steps)
            {
                ExecInitPruningContext(&pprune->initial_context,
                                       pinfo->initial_pruning_steps,
                                       partdesc, partkey, planstate);
                /* Record whether initial pruning is needed at any level */
                prunestate->do_initial_prune = true;
            }
            pprune->exec_pruning_steps = pinfo->exec_pruning_steps;
            if (pinfo->exec_pruning_steps)
            {
                ExecInitPruningContext(&pprune->exec_context,
                                       pinfo->exec_pruning_steps,
                                       partdesc, partkey, planstate);
                /* Record whether exec pruning is needed at any level */
                prunestate->do_exec_prune = true;
            }

            /*
             * Accumulate the IDs of all PARAM_EXEC Params affecting the
             * partitioning decisions at this plan node.
             */
            prunestate->execparamids = bms_add_members(prunestate->execparamids,
                                                       pinfo->execparamids);

            j++;
        }
        i++;
    }

    return prunestate;
}

ExecFindInitialMatchingSubPlans()

Bitmapset* ExecFindInitialMatchingSubPlans	(	PartitionPruneState *	prunestate,
		int	nsubplans
	)

Definition at line 1823 of file execPartition.c.

References Assert, bms_add_member(), bms_add_members(), bms_copy(), bms_free(), bms_is_empty(), bms_next_member(), bms_num_members(), PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, find_matching_subplans_recurse(), i, PartitionedRelPruningData::initial_context, PartitionedRelPruningData::initial_pruning_steps, MemoryContextReset(), MemoryContextSwitchTo(), PartitionedRelPruningData::nparts, PartitionPruneState::num_partprunedata, PartitionPruningData::num_partrelprunedata, PartitionPruneState::other_subplans, palloc0(), PartitionPruneState::partprunedata, PartitionPruningData::partrelprunedata, pfree(), PartitionPruneContext::planstate, PartitionedRelPruningData::present_parts, PartitionPruneState::prune_context, PlanState::ps_ExprContext, ResetExprContext, PartitionedRelPruningData::subpart_map, and PartitionedRelPruningData::subplan_map.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

{
    Bitmapset  *result = NULL;
    MemoryContext oldcontext;
    int         i;

    /* Caller error if we get here without do_initial_prune */
    Assert(prunestate->do_initial_prune);

    /*
     * Switch to a temp context to avoid leaking memory in the executor's
     * query-lifespan memory context.
     */
    oldcontext = MemoryContextSwitchTo(prunestate->prune_context);

    /*
     * For each hierarchy, do the pruning tests, and add nondeletable
     * subplans' indexes to "result".
     */
    for (i = 0; i < prunestate->num_partprunedata; i++)
    {
        PartitionPruningData *prunedata;
        PartitionedRelPruningData *pprune;

        prunedata = prunestate->partprunedata[i];
        pprune = &prunedata->partrelprunedata[0];

        /* Perform pruning without using PARAM_EXEC Params */
        find_matching_subplans_recurse(prunedata, pprune, true, &result);

        /* Expression eval may have used space in node's ps_ExprContext too */
        if (pprune->initial_pruning_steps)
            ResetExprContext(pprune->initial_context.planstate->ps_ExprContext);
    }

    /* Add in any subplans that partition pruning didn't account for */
    result = bms_add_members(result, prunestate->other_subplans);

    MemoryContextSwitchTo(oldcontext);

    /* Copy result out of the temp context before we reset it */
    result = bms_copy(result);

    MemoryContextReset(prunestate->prune_context);

    /*
     * If exec-time pruning is required and we pruned subplans above, then we
     * must re-sequence the subplan indexes so that ExecFindMatchingSubPlans
     * properly returns the indexes from the subplans which will remain after
     * execution of this function.
     *
     * We can safely skip this when !do_exec_prune, even though that leaves
     * invalid data in prunestate, because that data won't be consulted again
     * (cf initial Assert in ExecFindMatchingSubPlans).
     */
    if (prunestate->do_exec_prune && bms_num_members(result) < nsubplans)
    {
        int        *new_subplan_indexes;
        Bitmapset  *new_other_subplans;
        int         i;
        int         newidx;

        /*
         * First we must build a temporary array which maps old subplan
         * indexes to new ones.  For convenience of initialization, we use
         * 1-based indexes in this array and leave pruned items as 0.
         */
        new_subplan_indexes = (int *) palloc0(sizeof(int) * nsubplans);
        newidx = 1;
        i = -1;
        while ((i = bms_next_member(result, i)) >= 0)
        {
            Assert(i < nsubplans);
            new_subplan_indexes[i] = newidx++;
        }

        /*
         * Now we can update each PartitionedRelPruneInfo's subplan_map with
         * new subplan indexes.  We must also recompute its present_parts
         * bitmap.
         */
        for (i = 0; i < prunestate->num_partprunedata; i++)
        {
            PartitionPruningData *prunedata = prunestate->partprunedata[i];
            int         j;

            /*
             * Within each hierarchy, we perform this loop in back-to-front
             * order so that we determine present_parts for the lowest-level
             * partitioned tables first.  This way we can tell whether a
             * sub-partitioned table's partitions were entirely pruned so we
             * can exclude it from the current level's present_parts.
             */
            for (j = prunedata->num_partrelprunedata - 1; j >= 0; j--)
            {
                PartitionedRelPruningData *pprune = &prunedata->partrelprunedata[j];
                int         nparts = pprune->nparts;
                int         k;

                /* We just rebuild present_parts from scratch */
                bms_free(pprune->present_parts);
                pprune->present_parts = NULL;

                for (k = 0; k < nparts; k++)
                {
                    int         oldidx = pprune->subplan_map[k];
                    int         subidx;

                    /*
                     * If this partition existed as a subplan then change the
                     * old subplan index to the new subplan index.  The new
                     * index may become -1 if the partition was pruned above,
                     * or it may just come earlier in the subplan list due to
                     * some subplans being removed earlier in the list.  If
                     * it's a subpartition, add it to present_parts unless
                     * it's entirely pruned.
                     */
                    if (oldidx >= 0)
                    {
                        Assert(oldidx < nsubplans);
                        pprune->subplan_map[k] = new_subplan_indexes[oldidx] - 1;

                        if (new_subplan_indexes[oldidx] > 0)
                            pprune->present_parts =
                                bms_add_member(pprune->present_parts, k);
                    }
                    else if ((subidx = pprune->subpart_map[k]) >= 0)
                    {
                        PartitionedRelPruningData *subprune;

                        subprune = &prunedata->partrelprunedata[subidx];

                        if (!bms_is_empty(subprune->present_parts))
                            pprune->present_parts =
                                bms_add_member(pprune->present_parts, k);
                    }
                }
            }
        }

        /*
         * We must also recompute the other_subplans set, since indexes in it
         * may change.
         */
        new_other_subplans = NULL;
        i = -1;
        while ((i = bms_next_member(prunestate->other_subplans, i)) >= 0)
            new_other_subplans = bms_add_member(new_other_subplans,
                                                new_subplan_indexes[i] - 1);

        bms_free(prunestate->other_subplans);
        prunestate->other_subplans = new_other_subplans;

        pfree(new_subplan_indexes);
    }

    return result;
}

ExecFindMatchingSubPlans()

Bitmapset* ExecFindMatchingSubPlans

(

PartitionPruneState *

prunestate

)

Definition at line 1990 of file execPartition.c.

References Assert, bms_add_members(), bms_copy(), PartitionPruneState::do_exec_prune, PartitionedRelPruningData::exec_context, PartitionedRelPruningData::exec_pruning_steps, find_matching_subplans_recurse(), i, MemoryContextReset(), MemoryContextSwitchTo(), PartitionPruneState::num_partprunedata, PartitionPruneState::other_subplans, PartitionPruneState::partprunedata, PartitionPruningData::partrelprunedata, PartitionPruneContext::planstate, PartitionPruneState::prune_context, PlanState::ps_ExprContext, and ResetExprContext.

Referenced by choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), choose_next_subplan_locally(), ExecAppendAsyncBegin(), and ExecMergeAppend().

{
    Bitmapset  *result = NULL;
    MemoryContext oldcontext;
    int         i;

    /*
     * If !do_exec_prune, we've got problems because
     * ExecFindInitialMatchingSubPlans will not have bothered to update
     * prunestate for whatever pruning it did.
     */
    Assert(prunestate->do_exec_prune);

    /*
     * Switch to a temp context to avoid leaking memory in the executor's
     * query-lifespan memory context.
     */
    oldcontext = MemoryContextSwitchTo(prunestate->prune_context);

    /*
     * For each hierarchy, do the pruning tests, and add nondeletable
     * subplans' indexes to "result".
     */
    for (i = 0; i < prunestate->num_partprunedata; i++)
    {
        PartitionPruningData *prunedata;
        PartitionedRelPruningData *pprune;

        prunedata = prunestate->partprunedata[i];
        pprune = &prunedata->partrelprunedata[0];

        find_matching_subplans_recurse(prunedata, pprune, false, &result);

        /* Expression eval may have used space in node's ps_ExprContext too */
        if (pprune->exec_pruning_steps)
            ResetExprContext(pprune->exec_context.planstate->ps_ExprContext);
    }

    /* Add in any subplans that partition pruning didn't account for */
    result = bms_add_members(result, prunestate->other_subplans);

    MemoryContextSwitchTo(oldcontext);

    /* Copy result out of the temp context before we reset it */
    result = bms_copy(result);

    MemoryContextReset(prunestate->prune_context);

    return result;
}

ExecFindPartition()

ResultRelInfo* ExecFindPartition	(	ModifyTableState *	mtstate,
		ResultRelInfo *	rootResultRelInfo,
		PartitionTupleRouting *	proute,
		TupleTableSlot *	slot,
		EState *	estate
	)

Definition at line 257 of file execPartition.c.

References Assert, TupleConversionMap::attrMap, PartitionDescData::boundinfo, CHECK_FOR_INTERRUPTS, CheckValidResultRel(), CMD_INSERT, PartitionBoundInfoData::default_index, ExprContext::ecxt_scantuple, ereport, errcode(), errdetail(), errmsg(), ERROR, errtable(), ExecBuildSlotPartitionKeyDescription(), ExecClearTuple(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecLookupResultRelByOid(), ExecPartitionCheck(), execute_attr_map_slot(), FormPartitionKeyDatum(), get_partition_for_tuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, PartitionDispatchData::indexes, PartitionDescData::is_leaf, likely, MemoryContextSwitchTo(), PartitionTupleRouting::nonleaf_partitions, PartitionDescData::nparts, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, OidIsValid, PartitionDescData::oids, PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PARTITION_MAX_KEYS, PartitionTupleRouting::partitions, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, PartitionDispatchData::reldesc, ResultRelInfo::ri_PartitionTupleSlot, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootToPartitionMap, ModifyTableState::rootResultRelInfo, PartitionDispatchData::tupmap, PartitionDispatchData::tupslot, and values.

Referenced by apply_handle_tuple_routing(), CopyFrom(), and ExecPrepareTupleRouting().

{
    PartitionDispatch *pd = proute->partition_dispatch_info;
    Datum       values[PARTITION_MAX_KEYS];
    bool        isnull[PARTITION_MAX_KEYS];
    Relation    rel;
    PartitionDispatch dispatch;
    PartitionDesc partdesc;
    ExprContext *ecxt = GetPerTupleExprContext(estate);
    TupleTableSlot *ecxt_scantuple_saved = ecxt->ecxt_scantuple;
    TupleTableSlot *rootslot = slot;
    TupleTableSlot *myslot = NULL;
    MemoryContext oldcxt;
    ResultRelInfo *rri = NULL;

    /* use per-tuple context here to avoid leaking memory */
    oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));

    /*
     * First check the root table's partition constraint, if any.  No point in
     * routing the tuple if it doesn't belong in the root table itself.
     */
    if (rootResultRelInfo->ri_RelationDesc->rd_rel->relispartition)
        ExecPartitionCheck(rootResultRelInfo, slot, estate, true);

    /* start with the root partitioned table */
    dispatch = pd[0];
    while (dispatch != NULL)
    {
        int         partidx = -1;
        bool        is_leaf;

        CHECK_FOR_INTERRUPTS();

        rel = dispatch->reldesc;
        partdesc = dispatch->partdesc;

        /*
         * Extract partition key from tuple. Expression evaluation machinery
         * that FormPartitionKeyDatum() invokes expects ecxt_scantuple to
         * point to the correct tuple slot.  The slot might have changed from
         * what was used for the parent table if the table of the current
         * partitioning level has different tuple descriptor from the parent.
         * So update ecxt_scantuple accordingly.
         */
        ecxt->ecxt_scantuple = slot;
        FormPartitionKeyDatum(dispatch, slot, estate, values, isnull);

        /*
         * If this partitioned table has no partitions or no partition for
         * these values, error out.
         */
        if (partdesc->nparts == 0 ||
            (partidx = get_partition_for_tuple(dispatch, values, isnull)) < 0)
        {
            char       *val_desc;

            val_desc = ExecBuildSlotPartitionKeyDescription(rel,
                                                            values, isnull, 64);
            Assert(OidIsValid(RelationGetRelid(rel)));
            ereport(ERROR,
                    (errcode(ERRCODE_CHECK_VIOLATION),
                     errmsg("no partition of relation \"%s\" found for row",
                            RelationGetRelationName(rel)),
                     val_desc ?
                     errdetail("Partition key of the failing row contains %s.",
                               val_desc) : 0,
                     errtable(rel)));
        }

        is_leaf = partdesc->is_leaf[partidx];
        if (is_leaf)
        {
            /*
             * We've reached the leaf -- hurray, we're done.  Look to see if
             * we've already got a ResultRelInfo for this partition.
             */
            if (likely(dispatch->indexes[partidx] >= 0))
            {
                /* ResultRelInfo already built */
                Assert(dispatch->indexes[partidx] < proute->num_partitions);
                rri = proute->partitions[dispatch->indexes[partidx]];
            }
            else
            {
                /*
                 * If the partition is known in the owning ModifyTableState
                 * node, we can re-use that ResultRelInfo instead of creating
                 * a new one with ExecInitPartitionInfo().
                 */
                rri = ExecLookupResultRelByOid(mtstate,
                                               partdesc->oids[partidx],
                                               true, false);
                if (rri)
                {
                    /* Verify this ResultRelInfo allows INSERTs */
                    CheckValidResultRel(rri, CMD_INSERT);

                    /*
                     * Initialize information needed to insert this and
                     * subsequent tuples routed to this partition.
                     */
                    ExecInitRoutingInfo(mtstate, estate, proute, dispatch,
                                        rri, partidx, true);
                }
                else
                {
                    /* We need to create a new one. */
                    rri = ExecInitPartitionInfo(mtstate, estate, proute,
                                                dispatch,
                                                rootResultRelInfo, partidx);
                }
            }
            Assert(rri != NULL);

            /* Signal to terminate the loop */
            dispatch = NULL;
        }
        else
        {
            /*
             * Partition is a sub-partitioned table; get the PartitionDispatch
             */
            if (likely(dispatch->indexes[partidx] >= 0))
            {
                /* Already built. */
                Assert(dispatch->indexes[partidx] < proute->num_dispatch);

                rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];

                /*
                 * Move down to the next partition level and search again
                 * until we find a leaf partition that matches this tuple
                 */
                dispatch = pd[dispatch->indexes[partidx]];
            }
            else
            {
                /* Not yet built. Do that now. */
                PartitionDispatch subdispatch;

                /*
                 * Create the new PartitionDispatch.  We pass the current one
                 * in as the parent PartitionDispatch
                 */
                subdispatch = ExecInitPartitionDispatchInfo(estate,
                                                            proute,
                                                            partdesc->oids[partidx],
                                                            dispatch, partidx,
                                                            mtstate->rootResultRelInfo);
                Assert(dispatch->indexes[partidx] >= 0 &&
                       dispatch->indexes[partidx] < proute->num_dispatch);

                rri = proute->nonleaf_partitions[dispatch->indexes[partidx]];
                dispatch = subdispatch;
            }

            /*
             * Convert the tuple to the new parent's layout, if different from
             * the previous parent.
             */
            if (dispatch->tupslot)
            {
                AttrMap    *map = dispatch->tupmap;
                TupleTableSlot *tempslot = myslot;

                myslot = dispatch->tupslot;
                slot = execute_attr_map_slot(map, slot, myslot);

                if (tempslot != NULL)
                    ExecClearTuple(tempslot);
            }
        }

        /*
         * If this partition is the default one, we must check its partition
         * constraint now, which may have changed concurrently due to
         * partitions being added to the parent.
         *
         * (We do this here, and do not rely on ExecInsert doing it, because
         * we don't want to miss doing it for non-leaf partitions.)
         */
        if (partidx == partdesc->boundinfo->default_index)
        {
            /*
             * The tuple must match the partition's layout for the constraint
             * expression to be evaluated successfully.  If the partition is
             * sub-partitioned, that would already be the case due to the code
             * above, but for a leaf partition the tuple still matches the
             * parent's layout.
             *
             * Note that we have a map to convert from root to current
             * partition, but not from immediate parent to current partition.
             * So if we have to convert, do it from the root slot; if not, use
             * the root slot as-is.
             */
            if (is_leaf)
            {
                TupleConversionMap *map = rri->ri_RootToPartitionMap;

                if (map)
                    slot = execute_attr_map_slot(map->attrMap, rootslot,
                                                 rri->ri_PartitionTupleSlot);
                else
                    slot = rootslot;
            }

            ExecPartitionCheck(rri, slot, estate, true);
        }
    }

    /* Release the tuple in the lowest parent's dedicated slot. */
    if (myslot != NULL)
        ExecClearTuple(myslot);
    /* and restore ecxt's scantuple */
    ecxt->ecxt_scantuple = ecxt_scantuple_saved;
    MemoryContextSwitchTo(oldcxt);

    return rri;
}

ExecSetupPartitionTupleRouting()

PartitionTupleRouting* ExecSetupPartitionTupleRouting	(	EState *	estate,
		Relation	rel
	)

Definition at line 210 of file execPartition.c.

References CurrentMemoryContext, ExecInitPartitionDispatchInfo(), PartitionTupleRouting::memcxt, palloc0(), PartitionTupleRouting::partition_root, and RelationGetRelid.

Referenced by apply_handle_tuple_routing(), CopyFrom(), ExecCrossPartitionUpdate(), and ExecInitModifyTable().

{
    PartitionTupleRouting *proute;

    /*
     * Here we attempt to expend as little effort as possible in setting up
     * the PartitionTupleRouting.  Each partition's ResultRelInfo is built on
     * demand, only when we actually need to route a tuple to that partition.
     * The reason for this is that a common case is for INSERT to insert a
     * single tuple into a partitioned table and this must be fast.
     */
    proute = (PartitionTupleRouting *) palloc0(sizeof(PartitionTupleRouting));
    proute->partition_root = rel;
    proute->memcxt = CurrentMemoryContext;
    /* Rest of members initialized by zeroing */

    /*
     * Initialize this table's PartitionDispatch object.  Here we pass in the
     * parent as NULL as we don't need to care about any parent of the target
     * partitioned table.
     */
    ExecInitPartitionDispatchInfo(estate, proute, RelationGetRelid(rel),
                                  NULL, 0, NULL);

    return proute;
}