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)
void	ExecDoInitialPruning (EState *estate)
PartitionPruneState *	ExecInitPartitionExecPruning (PlanState *planstate, int n_total_subplans, int part_prune_index, Bitmapset *relids, Bitmapset **initially_valid_subplans)
Bitmapset *	ExecFindMatchingSubPlans (PartitionPruneState *prunestate, bool initial_prune, Bitmapset **validsubplan_rtis)

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 1374 of file execPartition.c.

{
    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);
    }
}

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().

ExecDoInitialPruning()

void ExecDoInitialPruning

(

EState *

estate

)

Definition at line 1957 of file execPartition.c.

{
    ListCell   *lc;
 
    foreach(lc, estate->es_part_prune_infos)
    {
        PartitionPruneInfo *pruneinfo = lfirst_node(PartitionPruneInfo, lc);
        PartitionPruneState *prunestate;
        Bitmapset  *validsubplans = NULL;
        Bitmapset  *all_leafpart_rtis = NULL;
        Bitmapset  *validsubplan_rtis = NULL;
 
        /* Create and save the PartitionPruneState. */
        prunestate = CreatePartitionPruneState(estate, pruneinfo,
                                               &all_leafpart_rtis);
        estate->es_part_prune_states = lappend(estate->es_part_prune_states,
                                               prunestate);
 
        /*
         * Perform initial pruning steps, if any, and save the result
         * bitmapset or NULL as described in the header comment.
         */
        if (prunestate->do_initial_prune)
            validsubplans = ExecFindMatchingSubPlans(prunestate, true,
                                                     &validsubplan_rtis);
        else
            validsubplan_rtis = all_leafpart_rtis;
 
        estate->es_unpruned_relids = bms_add_members(estate->es_unpruned_relids,
                                                     validsubplan_rtis);
        estate->es_part_prune_results = lappend(estate->es_part_prune_results,
                                                validsubplans);
    }
}

References bms_add_members(), CreatePartitionPruneState(), PartitionPruneState::do_initial_prune, EState::es_part_prune_infos, EState::es_part_prune_results, EState::es_part_prune_states, EState::es_unpruned_relids, ExecFindMatchingSubPlans(), lappend(), and lfirst_node.

Referenced by InitPlan().

ExecFindMatchingSubPlans()

Bitmapset * ExecFindMatchingSubPlans	(	PartitionPruneState *	prunestate,
		bool	initial_prune,
		Bitmapset **	validsubplan_rtis
	)

Definition at line 2631 of file execPartition.c.

{
    Bitmapset  *result = NULL;
    MemoryContext oldcontext;
    int         i;
 
    /*
     * Either we're here on the initial prune done during pruning
     * initialization, or we're at a point where PARAM_EXEC Params can be
     * evaluated *and* there are steps in which to do so.
     */
    Assert(initial_prune || prunestate->do_exec_prune);
    Assert(validsubplan_rtis != NULL || !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 = prunestate->partprunedata[i];
        PartitionedRelPruningData *pprune;
 
        /*
         * We pass the zeroth item, belonging to the root table of the
         * hierarchy, and find_matching_subplans_recurse() takes care of
         * recursing to other (lower-level) parents as needed.
         */
        pprune = &prunedata->partrelprunedata[0];
        find_matching_subplans_recurse(prunedata, pprune, initial_prune,
                                       &result, validsubplan_rtis);
 
        /*
         * Expression eval may have used space in ExprContext too. Avoid
         * accessing exec_context during initial pruning, as it is not valid
         * at that stage.
         */
        if (!initial_prune && pprune->exec_pruning_steps)
            ResetExprContext(pprune->exec_context.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);
    if (validsubplan_rtis)
        *validsubplan_rtis = bms_copy(*validsubplan_rtis);
 
    MemoryContextReset(prunestate->prune_context);
 
    return result;
}

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

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

ExecFindPartition()

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

Definition at line 266 of file execPartition.c.

{
    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)
                {
                    ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
 
                    /* Verify this ResultRelInfo allows INSERTs */
                    CheckValidResultRel(rri, CMD_INSERT,
                                        node ? node->onConflictAction : ONCONFLICT_NONE,
                                        NIL);
 
                    /*
                     * 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 = ExecGetRootToChildMap(rri, estate);
 
                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;
}

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(), ExecGetRootToChildMap(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecLookupResultRelByOid(), ExecPartitionCheck(), execute_attr_map_slot(), FormPartitionKeyDatum(), get_partition_for_tuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, PartitionDispatchData::indexes, PartitionDescData::is_leaf, likely, MemoryContextSwitchTo(), NIL, PartitionTupleRouting::nonleaf_partitions, PartitionDescData::nparts, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, OidIsValid, PartitionDescData::oids, ONCONFLICT_NONE, ModifyTable::onConflictAction, PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PARTITION_MAX_KEYS, PartitionTupleRouting::partitions, PlanState::plan, ModifyTableState::ps, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, PartitionDispatchData::reldesc, ResultRelInfo::ri_PartitionTupleSlot, ResultRelInfo::ri_RelationDesc, ModifyTableState::rootResultRelInfo, PartitionDispatchData::tupmap, PartitionDispatchData::tupslot, and values.

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

ExecInitPartitionExecPruning()

PartitionPruneState * ExecInitPartitionExecPruning	(	PlanState *	planstate,
		int	n_total_subplans,
		int	part_prune_index,
		Bitmapset *	relids,
		Bitmapset **	initially_valid_subplans
	)

Definition at line 2013 of file execPartition.c.

{
    PartitionPruneState *prunestate;
    EState     *estate = planstate->state;
    PartitionPruneInfo *pruneinfo;
 
    /* Obtain the pruneinfo we need. */
    pruneinfo = list_nth_node(PartitionPruneInfo, estate->es_part_prune_infos,
                              part_prune_index);
 
    /* Its relids better match the plan node's or the planner messed up. */
    if (!bms_equal(relids, pruneinfo->relids))
        elog(ERROR, "wrong pruneinfo with relids=%s found at part_prune_index=%d contained in plan node with relids=%s",
             bmsToString(pruneinfo->relids), part_prune_index,
             bmsToString(relids));
 
    /*
     * The PartitionPruneState would have been created by
     * ExecDoInitialPruning() and stored as the part_prune_index'th element of
     * EState.es_part_prune_states.
     */
    prunestate = list_nth(estate->es_part_prune_states, part_prune_index);
    Assert(prunestate != NULL);
 
    /* Use the result of initial pruning done by ExecDoInitialPruning(). */
    if (prunestate->do_initial_prune)
        *initially_valid_subplans = list_nth_node(Bitmapset,
                                                  estate->es_part_prune_results,
                                                  part_prune_index);
    else
    {
        /* No pruning, so we'll need to initialize all subplans */
        Assert(n_total_subplans > 0);
        *initially_valid_subplans = bms_add_range(NULL, 0,
                                                  n_total_subplans - 1);
    }
 
    /*
     * The exec pruning state must also be initialized, if needed, before it
     * can be used for pruning during execution.
     *
     * This also re-sequences subplan indexes contained in prunestate to
     * account for any that were removed due to initial pruning; refer to the
     * condition in InitExecPartitionPruneContexts() that is used to determine
     * whether to do this.  If no exec pruning needs to be done, we would thus
     * leave the maps to be in an invalid state, but that's ok since that data
     * won't be consulted again (cf initial Assert in
     * ExecFindMatchingSubPlans).
     */
    if (prunestate->do_exec_prune)
        InitExecPartitionPruneContexts(prunestate, planstate,
                                       *initially_valid_subplans,
                                       n_total_subplans);
 
    return prunestate;
}

References Assert(), bms_add_range(), bms_equal(), bmsToString(), PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, elog, ERROR, EState::es_part_prune_infos, EState::es_part_prune_results, EState::es_part_prune_states, InitExecPartitionPruneContexts(), list_nth(), list_nth_node, PartitionPruneInfo::relids, and PlanState::state.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

ExecSetupPartitionTupleRouting()

PartitionTupleRouting * ExecSetupPartitionTupleRouting	(	EState *	estate,
		Relation	rel
	)

Definition at line 219 of file execPartition.c.

{
    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;
}

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

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