#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	PartitionRoutingInfo

struct	PartitionedRelPruningData

struct	PartitionPruningData

struct	PartitionPruneState

Typedefs
typedef struct PartitionDispatchData *	PartitionDispatch

typedef struct PartitionTupleRouting	PartitionTupleRouting

typedef struct PartitionRoutingInfo	PartitionRoutingInfo

typedef struct PartitionedRelPruningData	PartitionedRelPruningData

typedef struct PartitionPruningData	PartitionPruningData

typedef struct PartitionPruneState	PartitionPruneState

Functions
PartitionTupleRouting *	ExecSetupPartitionTupleRouting (EState estate, ModifyTableState mtstate, 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

◆ PartitionRoutingInfo

typedef struct PartitionRoutingInfo PartitionRoutingInfo

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

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

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

 {
     HTAB       *htab = proute->subplan_resultrel_htab;
     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);
 
         /*
          * Check if this result rel is one belonging to the node's subplans,
          * if so, let ExecEndPlan() clean it up.
          */
         if (htab)
         {
             Oid         partoid;
             bool        found;
 
             partoid = RelationGetRelid(resultRelInfo->ri_RelationDesc);
 
             (void) hash_search(htab, &partoid, HASH_FIND, &found);
             if (found)
                 continue;
         }
 
         ExecCloseIndices(resultRelInfo);
         table_close(resultRelInfo->ri_RelationDesc, NoLock);
     }
 }

◆ ExecCreatePartitionPruneState()

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

Definition at line 1551 of file execPartition.c.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

 {
     EState     *estate = planstate->state;
     PartitionPruneState *prunestate;
     int         n_part_hierarchies;
     ListCell   *lc;
     int         i;
 
     if (estate->es_partition_directory == NULL)
         estate->es_partition_directory =
             CreatePartitionDirectory(estate->es_query_cxt);
 
     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.  Since detaching a
              * partition requires AccessExclusiveLock, no partitions can have
              * disappeared, nor can the bounds for any partition have changed.
              * 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 1839 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 2006 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(), 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 271 of file execPartition.c.

References Assert, CHECK_FOR_INTERRUPTS, CheckValidResultRel(), CMD_INSERT, ExprContext::ecxt_scantuple, ereport, errcode(), errdetail(), errmsg(), ERROR, errtable(), ExecBuildSlotPartitionKeyDescription(), ExecClearTuple(), ExecInitPartitionDispatchInfo(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecPartitionCheck(), execute_attr_map_slot(), FormPartitionKeyDatum(), get_partition_for_tuple(), GetPerTupleExprContext, GetPerTupleMemoryContext, HASH_FIND, hash_search(), PartitionDispatchData::indexes, PartitionDescData::is_leaf, likely, MemoryContextSwitchTo(), PartitionDescData::nparts, PartitionTupleRouting::num_dispatch, PartitionTupleRouting::num_partitions, OidIsValid, PartitionDescData::oids, PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PARTITION_MAX_KEYS, PartitionTupleRouting::partitions, ModifyTableState::ps, RelationGetRelationName, RelationGetRelid, PartitionDispatchData::reldesc, ResultRelInfo::ri_PartitionCheck, SubplanResultRelHashElem::rri, PlanState::state, PartitionTupleRouting::subplan_resultrel_htab, 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_old = ecxt->ecxt_scantuple;
     TupleTableSlot *myslot = NULL;
     MemoryContext oldcxt;
 
     /* 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_PartitionCheck)
         ExecPartitionCheck(rootResultRelInfo, slot, estate, true);
 
     /* start with the root partitioned table */
     dispatch = pd[0];
     while (true)
     {
         AttrMap    *map = dispatch->tupmap;
         int         partidx = -1;
 
         CHECK_FOR_INTERRUPTS();
 
         rel = dispatch->reldesc;
         partdesc = dispatch->partdesc;
 
         /*
          * Convert the tuple to this parent's layout, if different from the
          * current relation.
          */
         myslot = dispatch->tupslot;
         if (myslot != NULL)
         {
             Assert(map != NULL);
             slot = execute_attr_map_slot(map, slot, myslot);
         }
 
         /*
          * 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)));
         }
 
         if (partdesc->is_leaf[partidx])
         {
             ResultRelInfo *rri;
 
             /*
              * 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
             {
                 bool        found = false;
 
                 /*
                  * We have not yet set up a ResultRelInfo for this partition,
                  * but if we have a subplan hash table, we might have one
                  * there.  If not, we'll have to create one.
                  */
                 if (proute->subplan_resultrel_htab)
                 {
                     Oid         partoid = partdesc->oids[partidx];
                     SubplanResultRelHashElem *elem;
 
                     elem = hash_search(proute->subplan_resultrel_htab,
                                        &partoid, HASH_FIND, NULL);
                     if (elem)
                     {
                         found = true;
                         rri = elem->rri;
 
                         /* Verify this ResultRelInfo allows INSERTs */
                         CheckValidResultRel(rri, CMD_INSERT);
 
                         /* Set up the PartitionRoutingInfo for it */
                         ExecInitRoutingInfo(mtstate, estate, proute, dispatch,
                                             rri, partidx);
                     }
                 }
 
                 /* We need to create a new one. */
                 if (!found)
                     rri = ExecInitPartitionInfo(mtstate, estate, proute,
                                                 dispatch,
                                                 rootResultRelInfo, partidx);
             }
 
             /* Release the tuple in the lowest parent's dedicated slot. */
             if (slot == myslot)
                 ExecClearTuple(myslot);
 
             MemoryContextSwitchTo(oldcxt);
             ecxt->ecxt_scantuple = ecxt_scantuple_old;
             return rri;
         }
         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);
 
                 /*
                  * 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(mtstate->ps.state,
                                                             proute,
                                                             partdesc->oids[partidx],
                                                             dispatch, partidx);
                 Assert(dispatch->indexes[partidx] >= 0 &&
                        dispatch->indexes[partidx] < proute->num_dispatch);
                 dispatch = subdispatch;
             }
         }
     }
 }

◆ ExecSetupPartitionTupleRouting()

PartitionTupleRouting* ExecSetupPartitionTupleRouting	(	EState *	estate,
		ModifyTableState *	mtstate,
		Relation	rel
	)

Definition at line 211 of file execPartition.c.

References CMD_UPDATE, CurrentMemoryContext, ExecHashSubPlanResultRelsByOid(), ExecInitPartitionDispatchInfo(), PartitionTupleRouting::memcxt, ModifyTable::operation, palloc0(), PartitionTupleRouting::partition_root, PlanState::plan, ModifyTableState::ps, and RelationGetRelid.

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

 {
     PartitionTupleRouting *proute;
     ModifyTable *node = mtstate ? (ModifyTable *) mtstate->ps.plan : NULL;
 
     /*
      * 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);
 
     /*
      * If performing an UPDATE with tuple routing, we can reuse partition
      * sub-plan result rels.  We build a hash table to map the OIDs of
      * partitions present in mtstate->resultRelInfo to their ResultRelInfos.
      * Every time a tuple is routed to a partition that we've yet to set the
      * ResultRelInfo for, before we go to the trouble of making one, we check
      * for a pre-made one in the hash table.
      */
     if (node && node->operation == CMD_UPDATE)
         ExecHashSubPlanResultRelsByOid(mtstate, proute);
 
     return proute;
 }

Data Structures

Typedefs

Functions