#include "postgres.h"
#include "access/table.h"
#include "access/tableam.h"
#include "catalog/partition.h"
#include "executor/execPartition.h"
#include "executor/executor.h"
#include "executor/nodeModifyTable.h"
#include "foreign/fdwapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
#include "partitioning/partprune.h"
#include "rewrite/rewriteManip.h"
#include "utils/acl.h"
#include "utils/lsyscache.h"
#include "utils/partcache.h"
#include "utils/rls.h"
#include "utils/ruleutils.h"

Include dependency graph for execPartition.c:

Data Structures
struct	PartitionTupleRouting

struct	PartitionDispatchData

Macros
#define	PARTITION_CACHED_FIND_THRESHOLD 16

Typedefs
typedef struct PartitionDispatchData	PartitionDispatchData

Functions
static ResultRelInfo *	ExecInitPartitionInfo (ModifyTableState mtstate, EState estate, PartitionTupleRouting proute, PartitionDispatch dispatch, ResultRelInfo rootResultRelInfo, int partidx)

static void	ExecInitRoutingInfo (ModifyTableState mtstate, EState estate, PartitionTupleRouting proute, PartitionDispatch dispatch, ResultRelInfo partRelInfo, int partidx, bool is_borrowed_rel)

static PartitionDispatch	ExecInitPartitionDispatchInfo (EState estate, PartitionTupleRouting proute, Oid partoid, PartitionDispatch parent_pd, int partidx, ResultRelInfo *rootResultRelInfo)

static void	FormPartitionKeyDatum (PartitionDispatch pd, TupleTableSlot slot, EState estate, Datum values, bool isnull)

static int	get_partition_for_tuple (PartitionDispatch pd, Datum values, bool isnull)

static char *	ExecBuildSlotPartitionKeyDescription (Relation rel, Datum values, bool isnull, int maxfieldlen)

static List *	adjust_partition_colnos (List colnos, ResultRelInfo leaf_part_rri)

static List *	adjust_partition_colnos_using_map (List colnos, AttrMap attrMap)

static PartitionPruneState *	CreatePartitionPruneState (PlanState planstate, PartitionPruneInfo pruneinfo)

static void	InitPartitionPruneContext (PartitionPruneContext context, List pruning_steps, PartitionDesc partdesc, PartitionKey partkey, PlanState planstate, ExprContext econtext)

static void	PartitionPruneFixSubPlanMap (PartitionPruneState prunestate, Bitmapset initially_valid_subplans, int n_total_subplans)

static void	find_matching_subplans_recurse (PartitionPruningData prunedata, PartitionedRelPruningData pprune, bool initial_prune, Bitmapset **validsubplans)

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 *	ExecInitPartitionPruning (PlanState planstate, int n_total_subplans, PartitionPruneInfo pruneinfo, Bitmapset **initially_valid_subplans)

Bitmapset *	ExecFindMatchingSubPlans (PartitionPruneState *prunestate, bool initial_prune)

Macro Definition Documentation

◆ PARTITION_CACHED_FIND_THRESHOLD

#define PARTITION_CACHED_FIND_THRESHOLD 16

Definition at line 1346 of file execPartition.c.

Typedef Documentation

◆ PartitionDispatchData

typedef struct PartitionDispatchData PartitionDispatchData

Function Documentation

◆ adjust_partition_colnos()

static List * adjust_partition_colnos	(	List *	colnos,
		ResultRelInfo *	leaf_part_rri
	)

static

Definition at line 1697 of file execPartition.c.

 {
     TupleConversionMap *map = ExecGetChildToRootMap(leaf_part_rri);
  
     Assert(map != NULL);
  
     return adjust_partition_colnos_using_map(colnos, map->attrMap);
 }

References adjust_partition_colnos_using_map(), Assert, TupleConversionMap::attrMap, and ExecGetChildToRootMap().

Referenced by ExecInitPartitionInfo().

◆ adjust_partition_colnos_using_map()

static List * adjust_partition_colnos_using_map	(	List *	colnos,
		AttrMap *	attrMap
	)

static

Definition at line 1714 of file execPartition.c.

 {
     List       *new_colnos = NIL;
     ListCell   *lc;
  
     Assert(attrMap != NULL);    /* else we shouldn't be here */
  
     foreach(lc, colnos)
     {
         AttrNumber  parentattrno = lfirst_int(lc);
  
         if (parentattrno <= 0 ||
             parentattrno > attrMap->maplen ||
             attrMap->attnums[parentattrno - 1] == 0)
             elog(ERROR, "unexpected attno %d in target column list",
                  parentattrno);
         new_colnos = lappend_int(new_colnos,
                                  attrMap->attnums[parentattrno - 1]);
     }
  
     return new_colnos;
 }

References Assert, AttrMap::attnums, elog, ERROR, lappend_int(), lfirst_int, AttrMap::maplen, and NIL.

Referenced by adjust_partition_colnos(), and ExecInitPartitionInfo().

◆ CreatePartitionPruneState()

static PartitionPruneState * CreatePartitionPruneState	(	PlanState *	planstate,
		PartitionPruneInfo *	pruneinfo
	)

static

Definition at line 1865 of file execPartition.c.

 {
     EState     *estate = planstate->state;
     PartitionPruneState *prunestate;
     int         n_part_hierarchies;
     ListCell   *lc;
     int         i;
     ExprContext *econtext = planstate->ps_ExprContext;
  
     /* 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(pruneinfo->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(pruneinfo->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, pruneinfo->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.  Note that we must skip
              * execution-time partition pruning in EXPLAIN (GENERIC_PLAN),
              * since parameter values may be missing.
              */
             pprune->initial_pruning_steps = pinfo->initial_pruning_steps;
             if (pinfo->initial_pruning_steps &&
                 !(econtext->ecxt_estate->es_top_eflags & EXEC_FLAG_EXPLAIN_GENERIC))
             {
                 InitPartitionPruneContext(&pprune->initial_context,
                                           pinfo->initial_pruning_steps,
                                           partdesc, partkey, planstate,
                                           econtext);
                 /* 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 &&
                 !(econtext->ecxt_estate->es_top_eflags & EXEC_FLAG_EXPLAIN_GENERIC))
             {
                 InitPartitionPruneContext(&pprune->exec_context,
                                           pinfo->exec_pruning_steps,
                                           partdesc, partkey, planstate,
                                           econtext);
                 /* 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;
 }

Referenced by ExecInitPartitionPruning().

◆ ExecBuildSlotPartitionKeyDescription()

static char * ExecBuildSlotPartitionKeyDescription	(	Relation	rel,
		Datum *	values,
		bool *	isnull,
		int	maxfieldlen
	)

static

Definition at line 1609 of file execPartition.c.

 {
     StringInfoData buf;
     PartitionKey key = RelationGetPartitionKey(rel);
     int         partnatts = get_partition_natts(key);
     int         i;
     Oid         relid = RelationGetRelid(rel);
     AclResult   aclresult;
  
     if (check_enable_rls(relid, InvalidOid, true) == RLS_ENABLED)
         return NULL;
  
     /* If the user has table-level access, just go build the description. */
     aclresult = pg_class_aclcheck(relid, GetUserId(), ACL_SELECT);
     if (aclresult != ACLCHECK_OK)
     {
         /*
          * Step through the columns of the partition key and make sure the
          * user has SELECT rights on all of them.
          */
         for (i = 0; i < partnatts; i++)
         {
             AttrNumber  attnum = get_partition_col_attnum(key, i);
  
             /*
              * If this partition key column is an expression, we return no
              * detail rather than try to figure out what column(s) the
              * expression includes and if the user has SELECT rights on them.
              */
             if (attnum == InvalidAttrNumber ||
                 pg_attribute_aclcheck(relid, attnum, GetUserId(),
                                       ACL_SELECT) != ACLCHECK_OK)
                 return NULL;
         }
     }
  
     initStringInfo(&buf);
     appendStringInfo(&buf, "(%s) = (",
                      pg_get_partkeydef_columns(relid, true));
  
     for (i = 0; i < partnatts; i++)
     {
         char       *val;
         int         vallen;
  
         if (isnull[i])
             val = "null";
         else
         {
             Oid         foutoid;
             bool        typisvarlena;
  
             getTypeOutputInfo(get_partition_col_typid(key, i),
                               &foutoid, &typisvarlena);
             val = OidOutputFunctionCall(foutoid, values[i]);
         }
  
         if (i > 0)
             appendStringInfoString(&buf, ", ");
  
         /* truncate if needed */
         vallen = strlen(val);
         if (vallen <= maxfieldlen)
             appendBinaryStringInfo(&buf, val, vallen);
         else
         {
             vallen = pg_mbcliplen(val, vallen, maxfieldlen);
             appendBinaryStringInfo(&buf, val, vallen);
             appendStringInfoString(&buf, "...");
         }
     }
  
     appendStringInfoChar(&buf, ')');
  
     return buf.data;
 }

References ACL_SELECT, ACLCHECK_OK, appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), attnum, buf, check_enable_rls(), get_partition_col_attnum(), get_partition_col_typid(), get_partition_natts(), getTypeOutputInfo(), GetUserId(), i, initStringInfo(), InvalidAttrNumber, InvalidOid, sort-test::key, OidOutputFunctionCall(), pg_attribute_aclcheck(), pg_class_aclcheck(), pg_get_partkeydef_columns(), pg_mbcliplen(), RelationGetPartitionKey(), RelationGetRelid, RLS_ENABLED, val, and values.

Referenced by ExecFindPartition().

◆ ExecCleanupTupleRouting()

void ExecCleanupTupleRouting	(	ModifyTableState *	mtstate,
		PartitionTupleRouting *	proute
	)

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

◆ ExecFindMatchingSubPlans()

Bitmapset* ExecFindMatchingSubPlans	(	PartitionPruneState *	prunestate,
		bool	initial_prune
	)

Definition at line 2291 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);
  
     /*
      * 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);
  
         /* Expression eval may have used space in ExprContext too */
         if (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);
  
     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(), ExecInitPartitionPruning(), and ExecMergeAppend().

◆ ExecFindPartition()

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

Definition at line 262 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)
                 {
                     /* Verify this ResultRelInfo allows INSERTs */
                     CheckValidResultRel(rri, CMD_INSERT, 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, PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PARTITION_MAX_KEYS, PartitionTupleRouting::partitions, 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().

◆ ExecInitPartitionDispatchInfo()

static PartitionDispatch ExecInitPartitionDispatchInfo	(	EState *	estate,
		PartitionTupleRouting *	proute,
		Oid	partoid,
		PartitionDispatch	parent_pd,
		int	partidx,
		ResultRelInfo *	rootResultRelInfo
	)

static

Definition at line 1092 of file execPartition.c.

 {
     Relation    rel;
     PartitionDesc partdesc;
     PartitionDispatch pd;
     int         dispatchidx;
     MemoryContext oldcxt;
  
     /*
      * For data modification, it is better that executor does not include
      * partitions being detached, except when running in snapshot-isolation
      * mode.  This means that a read-committed transaction immediately gets a
      * "no partition for tuple" error when a tuple is inserted into a
      * partition that's being detached concurrently, but a transaction in
      * repeatable-read mode can still use such a partition.
      */
     if (estate->es_partition_directory == NULL)
         estate->es_partition_directory =
             CreatePartitionDirectory(estate->es_query_cxt,
                                      !IsolationUsesXactSnapshot());
  
     oldcxt = MemoryContextSwitchTo(proute->memcxt);
  
     /*
      * Only sub-partitioned tables need to be locked here.  The root
      * partitioned table will already have been locked as it's referenced in
      * the query's rtable.
      */
     if (partoid != RelationGetRelid(proute->partition_root))
         rel = table_open(partoid, RowExclusiveLock);
     else
         rel = proute->partition_root;
     partdesc = PartitionDirectoryLookup(estate->es_partition_directory, rel);
  
     pd = (PartitionDispatch) palloc(offsetof(PartitionDispatchData, indexes) +
                                     partdesc->nparts * sizeof(int));
     pd->reldesc = rel;
     pd->key = RelationGetPartitionKey(rel);
     pd->keystate = NIL;
     pd->partdesc = partdesc;
     if (parent_pd != NULL)
     {
         TupleDesc   tupdesc = RelationGetDescr(rel);
  
         /*
          * For sub-partitioned tables where the column order differs from its
          * direct parent partitioned table, we must store a tuple table slot
          * initialized with its tuple descriptor and a tuple conversion map to
          * convert a tuple from its parent's rowtype to its own.  This is to
          * make sure that we are looking at the correct row using the correct
          * tuple descriptor when computing its partition key for tuple
          * routing.
          */
         pd->tupmap = build_attrmap_by_name_if_req(RelationGetDescr(parent_pd->reldesc),
                                                   tupdesc,
                                                   false);
         pd->tupslot = pd->tupmap ?
             MakeSingleTupleTableSlot(tupdesc, &TTSOpsVirtual) : NULL;
     }
     else
     {
         /* Not required for the root partitioned table */
         pd->tupmap = NULL;
         pd->tupslot = NULL;
     }
  
     /*
      * Initialize with -1 to signify that the corresponding partition's
      * ResultRelInfo or PartitionDispatch has not been created yet.
      */
     memset(pd->indexes, -1, sizeof(int) * partdesc->nparts);
  
     /* Track in PartitionTupleRouting for later use */
     dispatchidx = proute->num_dispatch++;
  
     /* Allocate or enlarge the array, as needed */
     if (proute->num_dispatch >= proute->max_dispatch)
     {
         if (proute->max_dispatch == 0)
         {
             proute->max_dispatch = 4;
             proute->partition_dispatch_info = (PartitionDispatch *)
                 palloc(sizeof(PartitionDispatch) * proute->max_dispatch);
             proute->nonleaf_partitions = (ResultRelInfo **)
                 palloc(sizeof(ResultRelInfo *) * proute->max_dispatch);
         }
         else
         {
             proute->max_dispatch *= 2;
             proute->partition_dispatch_info = (PartitionDispatch *)
                 repalloc(proute->partition_dispatch_info,
                          sizeof(PartitionDispatch) * proute->max_dispatch);
             proute->nonleaf_partitions = (ResultRelInfo **)
                 repalloc(proute->nonleaf_partitions,
                          sizeof(ResultRelInfo *) * proute->max_dispatch);
         }
     }
     proute->partition_dispatch_info[dispatchidx] = pd;
  
     /*
      * If setting up a PartitionDispatch for a sub-partitioned table, we may
      * also need a minimally valid ResultRelInfo for checking the partition
      * constraint later; set that up now.
      */
     if (parent_pd)
     {
         ResultRelInfo *rri = makeNode(ResultRelInfo);
  
         InitResultRelInfo(rri, rel, 0, rootResultRelInfo, 0);
         proute->nonleaf_partitions[dispatchidx] = rri;
     }
     else
         proute->nonleaf_partitions[dispatchidx] = NULL;
  
     /*
      * Finally, if setting up a PartitionDispatch for a sub-partitioned table,
      * install a downlink in the parent to allow quick descent.
      */
     if (parent_pd)
     {
         Assert(parent_pd->indexes[partidx] == -1);
         parent_pd->indexes[partidx] = dispatchidx;
     }
  
     MemoryContextSwitchTo(oldcxt);
  
     return pd;
 }

References Assert, build_attrmap_by_name_if_req(), CreatePartitionDirectory(), EState::es_partition_directory, EState::es_query_cxt, PartitionDispatchData::indexes, InitResultRelInfo(), IsolationUsesXactSnapshot, PartitionDispatchData::key, PartitionDispatchData::keystate, makeNode, MakeSingleTupleTableSlot(), PartitionTupleRouting::max_dispatch, PartitionTupleRouting::memcxt, MemoryContextSwitchTo(), NIL, PartitionTupleRouting::nonleaf_partitions, PartitionDescData::nparts, PartitionTupleRouting::num_dispatch, palloc(), PartitionDispatchData::partdesc, PartitionTupleRouting::partition_dispatch_info, PartitionTupleRouting::partition_root, PartitionDirectoryLookup(), RelationGetDescr, RelationGetPartitionKey(), RelationGetRelid, PartitionDispatchData::reldesc, repalloc(), RowExclusiveLock, table_open(), TTSOpsVirtual, PartitionDispatchData::tupmap, and PartitionDispatchData::tupslot.

Referenced by ExecFindPartition(), and ExecSetupPartitionTupleRouting().

◆ ExecInitPartitionInfo()

static ResultRelInfo * ExecInitPartitionInfo	(	ModifyTableState *	mtstate,
		EState *	estate,
		PartitionTupleRouting *	proute,
		PartitionDispatch	dispatch,
		ResultRelInfo *	rootResultRelInfo,
		int	partidx
	)

static

Definition at line 495 of file execPartition.c.

 {
     ModifyTable *node = (ModifyTable *) mtstate->ps.plan;
     Oid         partOid = dispatch->partdesc->oids[partidx];
     Relation    partrel;
     int         firstVarno = mtstate->resultRelInfo[0].ri_RangeTableIndex;
     Relation    firstResultRel = mtstate->resultRelInfo[0].ri_RelationDesc;
     ResultRelInfo *leaf_part_rri;
     MemoryContext oldcxt;
     AttrMap    *part_attmap = NULL;
     bool        found_whole_row;
  
     oldcxt = MemoryContextSwitchTo(proute->memcxt);
  
     partrel = table_open(partOid, RowExclusiveLock);
  
     leaf_part_rri = makeNode(ResultRelInfo);
     InitResultRelInfo(leaf_part_rri,
                       partrel,
                       0,
                       rootResultRelInfo,
                       estate->es_instrument);
  
     /*
      * Verify result relation is a valid target for an INSERT.  An UPDATE of a
      * partition-key becomes a DELETE+INSERT operation, so this check is still
      * required when the operation is CMD_UPDATE.
      */
     CheckValidResultRel(leaf_part_rri, CMD_INSERT, NIL);
  
     /*
      * Open partition indices.  The user may have asked to check for conflicts
      * within this leaf partition and do "nothing" instead of throwing an
      * error.  Be prepared in that case by initializing the index information
      * needed by ExecInsert() to perform speculative insertions.
      */
     if (partrel->rd_rel->relhasindex &&
         leaf_part_rri->ri_IndexRelationDescs == NULL)
         ExecOpenIndices(leaf_part_rri,
                         (node != NULL &&
                          node->onConflictAction != ONCONFLICT_NONE));
  
     /*
      * Build WITH CHECK OPTION constraints for the partition.  Note that we
      * didn't build the withCheckOptionList for partitions within the planner,
      * but simple translation of varattnos will suffice.  This only occurs for
      * the INSERT case or in the case of UPDATE/MERGE tuple routing where we
      * didn't find a result rel to reuse.
      */
     if (node && node->withCheckOptionLists != NIL)
     {
         List       *wcoList;
         List       *wcoExprs = NIL;
         ListCell   *ll;
  
         /*
          * In the case of INSERT on a partitioned table, there is only one
          * plan.  Likewise, there is only one WCO list, not one per partition.
          * For UPDATE/MERGE, there are as many WCO lists as there are plans.
          */
         Assert((node->operation == CMD_INSERT &&
                 list_length(node->withCheckOptionLists) == 1 &&
                 list_length(node->resultRelations) == 1) ||
                (node->operation == CMD_UPDATE &&
                 list_length(node->withCheckOptionLists) ==
                 list_length(node->resultRelations)) ||
                (node->operation == CMD_MERGE &&
                 list_length(node->withCheckOptionLists) ==
                 list_length(node->resultRelations)));
  
         /*
          * Use the WCO list of the first plan as a reference to calculate
          * attno's for the WCO list of this partition.  In the INSERT case,
          * that refers to the root partitioned table, whereas in the UPDATE
          * tuple routing case, that refers to the first partition in the
          * mtstate->resultRelInfo array.  In any case, both that relation and
          * this partition should have the same columns, so we should be able
          * to map attributes successfully.
          */
         wcoList = linitial(node->withCheckOptionLists);
  
         /*
          * Convert Vars in it to contain this partition's attribute numbers.
          */
         part_attmap =
             build_attrmap_by_name(RelationGetDescr(partrel),
                                   RelationGetDescr(firstResultRel),
                                   false);
         wcoList = (List *)
             map_variable_attnos((Node *) wcoList,
                                 firstVarno, 0,
                                 part_attmap,
                                 RelationGetForm(partrel)->reltype,
                                 &found_whole_row);
         /* We ignore the value of found_whole_row. */
  
         foreach(ll, wcoList)
         {
             WithCheckOption *wco = lfirst_node(WithCheckOption, ll);
             ExprState  *wcoExpr = ExecInitQual(castNode(List, wco->qual),
                                                &mtstate->ps);
  
             wcoExprs = lappend(wcoExprs, wcoExpr);
         }
  
         leaf_part_rri->ri_WithCheckOptions = wcoList;
         leaf_part_rri->ri_WithCheckOptionExprs = wcoExprs;
     }
  
     /*
      * Build the RETURNING projection for the partition.  Note that we didn't
      * build the returningList for partitions within the planner, but simple
      * translation of varattnos will suffice.  This only occurs for the INSERT
      * case or in the case of UPDATE/MERGE tuple routing where we didn't find
      * a result rel to reuse.
      */
     if (node && node->returningLists != NIL)
     {
         TupleTableSlot *slot;
         ExprContext *econtext;
         List       *returningList;
  
         /* See the comment above for WCO lists. */
         Assert((node->operation == CMD_INSERT &&
                 list_length(node->returningLists) == 1 &&
                 list_length(node->resultRelations) == 1) ||
                (node->operation == CMD_UPDATE &&
                 list_length(node->returningLists) ==
                 list_length(node->resultRelations)) ||
                (node->operation == CMD_MERGE &&
                 list_length(node->returningLists) ==
                 list_length(node->resultRelations)));
  
         /*
          * Use the RETURNING list of the first plan as a reference to
          * calculate attno's for the RETURNING list of this partition.  See
          * the comment above for WCO lists for more details on why this is
          * okay.
          */
         returningList = linitial(node->returningLists);
  
         /*
          * Convert Vars in it to contain this partition's attribute numbers.
          */
         if (part_attmap == NULL)
             part_attmap =
                 build_attrmap_by_name(RelationGetDescr(partrel),
                                       RelationGetDescr(firstResultRel),
                                       false);
         returningList = (List *)
             map_variable_attnos((Node *) returningList,
                                 firstVarno, 0,
                                 part_attmap,
                                 RelationGetForm(partrel)->reltype,
                                 &found_whole_row);
         /* We ignore the value of found_whole_row. */
  
         leaf_part_rri->ri_returningList = returningList;
  
         /*
          * Initialize the projection itself.
          *
          * Use the slot and the expression context that would have been set up
          * in ExecInitModifyTable() for projection's output.
          */
         Assert(mtstate->ps.ps_ResultTupleSlot != NULL);
         slot = mtstate->ps.ps_ResultTupleSlot;
         Assert(mtstate->ps.ps_ExprContext != NULL);
         econtext = mtstate->ps.ps_ExprContext;
         leaf_part_rri->ri_projectReturning =
             ExecBuildProjectionInfo(returningList, econtext, slot,
                                     &mtstate->ps, RelationGetDescr(partrel));
     }
  
     /* Set up information needed for routing tuples to the partition. */
     ExecInitRoutingInfo(mtstate, estate, proute, dispatch,
                         leaf_part_rri, partidx, false);
  
     /*
      * If there is an ON CONFLICT clause, initialize state for it.
      */
     if (node && node->onConflictAction != ONCONFLICT_NONE)
     {
         TupleDesc   partrelDesc = RelationGetDescr(partrel);
         ExprContext *econtext = mtstate->ps.ps_ExprContext;
         ListCell   *lc;
         List       *arbiterIndexes = NIL;
  
         /*
          * If there is a list of arbiter indexes, map it to a list of indexes
          * in the partition.  We do that by scanning the partition's index
          * list and searching for ancestry relationships to each index in the
          * ancestor table.
          */
         if (rootResultRelInfo->ri_onConflictArbiterIndexes != NIL)
         {
             List       *childIdxs;
  
             childIdxs = RelationGetIndexList(leaf_part_rri->ri_RelationDesc);
  
             foreach(lc, childIdxs)
             {
                 Oid         childIdx = lfirst_oid(lc);
                 List       *ancestors;
                 ListCell   *lc2;
  
                 ancestors = get_partition_ancestors(childIdx);
                 foreach(lc2, rootResultRelInfo->ri_onConflictArbiterIndexes)
                 {
                     if (list_member_oid(ancestors, lfirst_oid(lc2)))
                         arbiterIndexes = lappend_oid(arbiterIndexes, childIdx);
                 }
                 list_free(ancestors);
             }
         }
  
         /*
          * If the resulting lists are of inequal length, something is wrong.
          * (This shouldn't happen, since arbiter index selection should not
          * pick up an invalid index.)
          */
         if (list_length(rootResultRelInfo->ri_onConflictArbiterIndexes) !=
             list_length(arbiterIndexes))
             elog(ERROR, "invalid arbiter index list");
         leaf_part_rri->ri_onConflictArbiterIndexes = arbiterIndexes;
  
         /*
          * In the DO UPDATE case, we have some more state to initialize.
          */
         if (node->onConflictAction == ONCONFLICT_UPDATE)
         {
             OnConflictSetState *onconfl = makeNode(OnConflictSetState);
             TupleConversionMap *map;
  
             map = ExecGetRootToChildMap(leaf_part_rri, estate);
  
             Assert(node->onConflictSet != NIL);
             Assert(rootResultRelInfo->ri_onConflict != NULL);
  
             leaf_part_rri->ri_onConflict = onconfl;
  
             /*
              * Need a separate existing slot for each partition, as the
              * partition could be of a different AM, even if the tuple
              * descriptors match.
              */
             onconfl->oc_Existing =
                 table_slot_create(leaf_part_rri->ri_RelationDesc,
                                   &mtstate->ps.state->es_tupleTable);
  
             /*
              * If the partition's tuple descriptor matches exactly the root
              * parent (the common case), we can re-use most of the parent's ON
              * CONFLICT SET state, skipping a bunch of work.  Otherwise, we
              * need to create state specific to this partition.
              */
             if (map == NULL)
             {
                 /*
                  * It's safe to reuse these from the partition root, as we
                  * only process one tuple at a time (therefore we won't
                  * overwrite needed data in slots), and the results of
                  * projections are independent of the underlying storage.
                  * Projections and where clauses themselves don't store state
                  * / are independent of the underlying storage.
                  */
                 onconfl->oc_ProjSlot =
                     rootResultRelInfo->ri_onConflict->oc_ProjSlot;
                 onconfl->oc_ProjInfo =
                     rootResultRelInfo->ri_onConflict->oc_ProjInfo;
                 onconfl->oc_WhereClause =
                     rootResultRelInfo->ri_onConflict->oc_WhereClause;
             }
             else
             {
                 List       *onconflset;
                 List       *onconflcols;
  
                 /*
                  * Translate expressions in onConflictSet to account for
                  * different attribute numbers.  For that, map partition
                  * varattnos twice: first to catch the EXCLUDED
                  * pseudo-relation (INNER_VAR), and second to handle the main
                  * target relation (firstVarno).
                  */
                 onconflset = copyObject(node->onConflictSet);
                 if (part_attmap == NULL)
                     part_attmap =
                         build_attrmap_by_name(RelationGetDescr(partrel),
                                               RelationGetDescr(firstResultRel),
                                               false);
                 onconflset = (List *)
                     map_variable_attnos((Node *) onconflset,
                                         INNER_VAR, 0,
                                         part_attmap,
                                         RelationGetForm(partrel)->reltype,
                                         &found_whole_row);
                 /* We ignore the value of found_whole_row. */
                 onconflset = (List *)
                     map_variable_attnos((Node *) onconflset,
                                         firstVarno, 0,
                                         part_attmap,
                                         RelationGetForm(partrel)->reltype,
                                         &found_whole_row);
                 /* We ignore the value of found_whole_row. */
  
                 /* Finally, adjust the target colnos to match the partition. */
                 onconflcols = adjust_partition_colnos(node->onConflictCols,
                                                       leaf_part_rri);
  
                 /* create the tuple slot for the UPDATE SET projection */
                 onconfl->oc_ProjSlot =
                     table_slot_create(partrel,
                                       &mtstate->ps.state->es_tupleTable);
  
                 /* build UPDATE SET projection state */
                 onconfl->oc_ProjInfo =
                     ExecBuildUpdateProjection(onconflset,
                                               true,
                                               onconflcols,
                                               partrelDesc,
                                               econtext,
                                               onconfl->oc_ProjSlot,
                                               &mtstate->ps);
  
                 /*
                  * If there is a WHERE clause, initialize state where it will
                  * be evaluated, mapping the attribute numbers appropriately.
                  * As with onConflictSet, we need to map partition varattnos
                  * to the partition's tupdesc.
                  */
                 if (node->onConflictWhere)
                 {
                     List       *clause;
  
                     clause = copyObject((List *) node->onConflictWhere);
                     clause = (List *)
                         map_variable_attnos((Node *) clause,
                                             INNER_VAR, 0,
                                             part_attmap,
                                             RelationGetForm(partrel)->reltype,
                                             &found_whole_row);
                     /* We ignore the value of found_whole_row. */
                     clause = (List *)
                         map_variable_attnos((Node *) clause,
                                             firstVarno, 0,
                                             part_attmap,
                                             RelationGetForm(partrel)->reltype,
                                             &found_whole_row);
                     /* We ignore the value of found_whole_row. */
                     onconfl->oc_WhereClause =
                         ExecInitQual((List *) clause, &mtstate->ps);
                 }
             }
         }
     }
  
     /*
      * Since we've just initialized this ResultRelInfo, it's not in any list
      * attached to the estate as yet.  Add it, so that it can be found later.
      *
      * Note that the entries in this list appear in no predetermined order,
      * because partition result rels are initialized as and when they're
      * needed.
      */
     MemoryContextSwitchTo(estate->es_query_cxt);
     estate->es_tuple_routing_result_relations =
         lappend(estate->es_tuple_routing_result_relations,
                 leaf_part_rri);
  
     /*
      * Initialize information about this partition that's needed to handle
      * MERGE.  We take the "first" result relation's mergeActionList as
      * reference and make copy for this relation, converting stuff that
      * references attribute numbers to match this relation's.
      *
      * This duplicates much of the logic in ExecInitMerge(), so something
      * changes there, look here too.
      */
     if (node && node->operation == CMD_MERGE)
     {
         List       *firstMergeActionList = linitial(node->mergeActionLists);
         ListCell   *lc;
         ExprContext *econtext = mtstate->ps.ps_ExprContext;
         Node       *joinCondition;
  
         if (part_attmap == NULL)
             part_attmap =
                 build_attrmap_by_name(RelationGetDescr(partrel),
                                       RelationGetDescr(firstResultRel),
                                       false);
  
         if (unlikely(!leaf_part_rri->ri_projectNewInfoValid))
             ExecInitMergeTupleSlots(mtstate, leaf_part_rri);
  
         /* Initialize state for join condition checking. */
         joinCondition =
             map_variable_attnos(linitial(node->mergeJoinConditions),
                                 firstVarno, 0,
                                 part_attmap,
                                 RelationGetForm(partrel)->reltype,
                                 &found_whole_row);
         /* We ignore the value of found_whole_row. */
         leaf_part_rri->ri_MergeJoinCondition =
             ExecInitQual((List *) joinCondition, &mtstate->ps);
  
         foreach(lc, firstMergeActionList)
         {
             /* Make a copy for this relation to be safe.  */
             MergeAction *action = copyObject(lfirst(lc));
             MergeActionState *action_state;
  
             /* Generate the action's state for this relation */
             action_state = makeNode(MergeActionState);
             action_state->mas_action = action;
  
             /* And put the action in the appropriate list */
             leaf_part_rri->ri_MergeActions[action->matchKind] =
                 lappend(leaf_part_rri->ri_MergeActions[action->matchKind],
                         action_state);
  
             switch (action->commandType)
             {
                 case CMD_INSERT:
  
                     /*
                      * ExecCheckPlanOutput() already done on the targetlist
                      * when "first" result relation initialized and it is same
                      * for all result relations.
                      */
                     action_state->mas_proj =
                         ExecBuildProjectionInfo(action->targetList, econtext,
                                                 leaf_part_rri->ri_newTupleSlot,
                                                 &mtstate->ps,
                                                 RelationGetDescr(partrel));
                     break;
                 case CMD_UPDATE:
  
                     /*
                      * Convert updateColnos from "first" result relation
                      * attribute numbers to this result rel's.
                      */
                     if (part_attmap)
                         action->updateColnos =
                             adjust_partition_colnos_using_map(action->updateColnos,
                                                               part_attmap);
                     action_state->mas_proj =
                         ExecBuildUpdateProjection(action->targetList,
                                                   true,
                                                   action->updateColnos,
                                                   RelationGetDescr(leaf_part_rri->ri_RelationDesc),
                                                   econtext,
                                                   leaf_part_rri->ri_newTupleSlot,
                                                   NULL);
                     break;
                 case CMD_DELETE:
                     break;
  
                 default:
                     elog(ERROR, "unknown action in MERGE WHEN clause");
             }
  
             /* found_whole_row intentionally ignored. */
             action->qual =
                 map_variable_attnos(action->qual,
                                     firstVarno, 0,
                                     part_attmap,
                                     RelationGetForm(partrel)->reltype,
                                     &found_whole_row);
             action_state->mas_whenqual =
                 ExecInitQual((List *) action->qual, &mtstate->ps);
         }
     }
     MemoryContextSwitchTo(oldcxt);
  
     return leaf_part_rri;
 }

References generate_unaccent_rules::action, adjust_partition_colnos(), adjust_partition_colnos_using_map(), Assert, build_attrmap_by_name(), castNode, CheckValidResultRel(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_UPDATE, copyObject, elog, ERROR, EState::es_instrument, EState::es_query_cxt, EState::es_tuple_routing_result_relations, EState::es_tupleTable, ExecBuildProjectionInfo(), ExecBuildUpdateProjection(), ExecGetRootToChildMap(), ExecInitMergeTupleSlots(), ExecInitQual(), ExecInitRoutingInfo(), ExecOpenIndices(), get_partition_ancestors(), InitResultRelInfo(), INNER_VAR, lappend(), lappend_oid(), lfirst, lfirst_node, lfirst_oid, linitial, list_free(), list_length(), list_member_oid(), makeNode, map_variable_attnos(), MergeActionState::mas_action, MergeActionState::mas_proj, MergeActionState::mas_whenqual, PartitionTupleRouting::memcxt, MemoryContextSwitchTo(), ModifyTable::mergeActionLists, ModifyTable::mergeJoinConditions, NIL, OnConflictSetState::oc_Existing, OnConflictSetState::oc_ProjInfo, OnConflictSetState::oc_ProjSlot, OnConflictSetState::oc_WhereClause, PartitionDescData::oids, ONCONFLICT_NONE, ONCONFLICT_UPDATE, ModifyTable::onConflictAction, ModifyTable::onConflictCols, ModifyTable::onConflictSet, ModifyTable::onConflictWhere, ModifyTable::operation, PartitionDispatchData::partdesc, PlanState::plan, ModifyTableState::ps, PlanState::ps_ExprContext, PlanState::ps_ResultTupleSlot, WithCheckOption::qual, RelationGetDescr, RelationGetForm, RelationGetIndexList(), ModifyTable::resultRelations, ModifyTableState::resultRelInfo, ModifyTable::returningLists, ResultRelInfo::ri_onConflict, ResultRelInfo::ri_onConflictArbiterIndexes, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RelationDesc, RowExclusiveLock, PlanState::state, table_open(), table_slot_create(), unlikely, and ModifyTable::withCheckOptionLists.

Referenced by ExecFindPartition().

◆ ExecInitPartitionPruning()

PartitionPruneState* ExecInitPartitionPruning	(	PlanState *	planstate,
		int	n_total_subplans,
		PartitionPruneInfo *	pruneinfo,
		Bitmapset **	initially_valid_subplans
	)

Definition at line 1799 of file execPartition.c.

 {
     PartitionPruneState *prunestate;
     EState     *estate = planstate->state;
  
     /* We may need an expression context to evaluate partition exprs */
     ExecAssignExprContext(estate, planstate);
  
     /* Create the working data structure for pruning */
     prunestate = CreatePartitionPruneState(planstate, pruneinfo);
  
     /*
      * Perform an initial partition prune pass, if required.
      */
     if (prunestate->do_initial_prune)
         *initially_valid_subplans = ExecFindMatchingSubPlans(prunestate, true);
     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);
     }
  
     /*
      * Re-sequence subplan indexes contained in prunestate to account for any
      * that were removed above due to initial pruning.  No need to do this if
      * no steps were removed.
      */
     if (bms_num_members(*initially_valid_subplans) < n_total_subplans)
     {
         /*
          * 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)
             PartitionPruneFixSubPlanMap(prunestate,
                                         *initially_valid_subplans,
                                         n_total_subplans);
     }
  
     return prunestate;
 }

References Assert, bms_add_range(), bms_num_members(), CreatePartitionPruneState(), PartitionPruneState::do_exec_prune, PartitionPruneState::do_initial_prune, ExecAssignExprContext(), ExecFindMatchingSubPlans(), PartitionPruneFixSubPlanMap(), and PlanState::state.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

◆ ExecInitRoutingInfo()

static void ExecInitRoutingInfo	(	ModifyTableState *	mtstate,
		EState *	estate,
		PartitionTupleRouting *	proute,
		PartitionDispatch	dispatch,
		ResultRelInfo *	partRelInfo,
		int	partidx,
		bool	is_borrowed_rel
	)

static

Definition at line 984 of file execPartition.c.

 {
     MemoryContext oldcxt;
     int         rri_index;
  
     oldcxt = MemoryContextSwitchTo(proute->memcxt);
  
     /*
      * Set up tuple conversion between root parent and the partition if the
      * two have different rowtypes.  If conversion is indeed required, also
      * initialize a slot dedicated to storing this partition's converted
      * tuples.  Various operations that are applied to tuples after routing,
      * such as checking constraints, will refer to this slot.
      */
     if (ExecGetRootToChildMap(partRelInfo, estate) != NULL)
     {
         Relation    partrel = partRelInfo->ri_RelationDesc;
  
         /*
          * This pins the partition's TupleDesc, which will be released at the
          * end of the command.
          */
         partRelInfo->ri_PartitionTupleSlot =
             table_slot_create(partrel, &estate->es_tupleTable);
     }
     else
         partRelInfo->ri_PartitionTupleSlot = NULL;
  
     /*
      * If the partition is a foreign table, let the FDW init itself for
      * routing tuples to the partition.
      */
     if (partRelInfo->ri_FdwRoutine != NULL &&
         partRelInfo->ri_FdwRoutine->BeginForeignInsert != NULL)
         partRelInfo->ri_FdwRoutine->BeginForeignInsert(mtstate, partRelInfo);
  
     /*
      * Determine if the FDW supports batch insert and determine the batch size
      * (a FDW may support batching, but it may be disabled for the
      * server/table or for this particular query).
      *
      * If the FDW does not support batching, we set the batch size to 1.
      */
     if (partRelInfo->ri_FdwRoutine != NULL &&
         partRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize &&
         partRelInfo->ri_FdwRoutine->ExecForeignBatchInsert)
         partRelInfo->ri_BatchSize =
             partRelInfo->ri_FdwRoutine->GetForeignModifyBatchSize(partRelInfo);
     else
         partRelInfo->ri_BatchSize = 1;
  
     Assert(partRelInfo->ri_BatchSize >= 1);
  
     partRelInfo->ri_CopyMultiInsertBuffer = NULL;
  
     /*
      * Keep track of it in the PartitionTupleRouting->partitions array.
      */
     Assert(dispatch->indexes[partidx] == -1);
  
     rri_index = proute->num_partitions++;
  
     /* Allocate or enlarge the array, as needed */
     if (proute->num_partitions >= proute->max_partitions)
     {
         if (proute->max_partitions == 0)
         {
             proute->max_partitions = 8;
             proute->partitions = (ResultRelInfo **)
                 palloc(sizeof(ResultRelInfo *) * proute->max_partitions);
             proute->is_borrowed_rel = (bool *)
                 palloc(sizeof(bool) * proute->max_partitions);
         }
         else
         {
             proute->max_partitions *= 2;
             proute->partitions = (ResultRelInfo **)
                 repalloc(proute->partitions, sizeof(ResultRelInfo *) *
                          proute->max_partitions);
             proute->is_borrowed_rel = (bool *)
                 repalloc(proute->is_borrowed_rel, sizeof(bool) *
                          proute->max_partitions);
         }
     }
  
     proute->partitions[rri_index] = partRelInfo;
     proute->is_borrowed_rel[rri_index] = is_borrowed_rel;
     dispatch->indexes[partidx] = rri_index;
  
     MemoryContextSwitchTo(oldcxt);
 }

References Assert, FdwRoutine::BeginForeignInsert, EState::es_tupleTable, FdwRoutine::ExecForeignBatchInsert, ExecGetRootToChildMap(), FdwRoutine::GetForeignModifyBatchSize, PartitionDispatchData::indexes, PartitionTupleRouting::is_borrowed_rel, PartitionTupleRouting::max_partitions, PartitionTupleRouting::memcxt, MemoryContextSwitchTo(), PartitionTupleRouting::num_partitions, palloc(), PartitionTupleRouting::partitions, repalloc(), ResultRelInfo::ri_BatchSize, ResultRelInfo::ri_CopyMultiInsertBuffer, ResultRelInfo::ri_FdwRoutine, ResultRelInfo::ri_PartitionTupleSlot, ResultRelInfo::ri_RelationDesc, and table_slot_create().

Referenced by ExecFindPartition(), and ExecInitPartitionInfo().

◆ ExecSetupPartitionTupleRouting()

PartitionTupleRouting* ExecSetupPartitionTupleRouting	(	EState *	estate,
		Relation	rel
	)

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

◆ find_matching_subplans_recurse()

static void find_matching_subplans_recurse	(	PartitionPruningData *	prunedata,
		PartitionedRelPruningData *	pprune,
		bool	initial_prune,
		Bitmapset **	validsubplans
	)

static

Definition at line 2354 of file execPartition.c.

 {
     Bitmapset  *partset;
     int         i;
  
     /* Guard against stack overflow due to overly deep partition hierarchy. */
     check_stack_depth();
  
     /*
      * Prune as appropriate, if we have pruning steps matching the current
      * execution context.  Otherwise just include all partitions at this
      * level.
      */
     if (initial_prune && pprune->initial_pruning_steps)
         partset = get_matching_partitions(&pprune->initial_context,
                                           pprune->initial_pruning_steps);
     else if (!initial_prune && pprune->exec_pruning_steps)
         partset = get_matching_partitions(&pprune->exec_context,
                                           pprune->exec_pruning_steps);
     else
         partset = pprune->present_parts;
  
     /* Translate partset into subplan indexes */
     i = -1;
     while ((i = bms_next_member(partset, i)) >= 0)
     {
         if (pprune->subplan_map[i] >= 0)
             *validsubplans = bms_add_member(*validsubplans,
                                             pprune->subplan_map[i]);
         else
         {
             int         partidx = pprune->subpart_map[i];
  
             if (partidx >= 0)
                 find_matching_subplans_recurse(prunedata,
                                                &prunedata->partrelprunedata[partidx],
                                                initial_prune, validsubplans);
             else
             {
                 /*
                  * We get here if the planner already pruned all the sub-
                  * partitions for this partition.  Silently ignore this
                  * partition in this case.  The end result is the same: we
                  * would have pruned all partitions just the same, but we
                  * don't have any pruning steps to execute to verify this.
                  */
             }
         }
     }
 }

References bms_add_member(), bms_next_member(), check_stack_depth(), PartitionedRelPruningData::exec_context, PartitionedRelPruningData::exec_pruning_steps, get_matching_partitions(), i, PartitionedRelPruningData::initial_context, PartitionedRelPruningData::initial_pruning_steps, PartitionPruningData::partrelprunedata, PartitionedRelPruningData::present_parts, PartitionedRelPruningData::subpart_map, and PartitionedRelPruningData::subplan_map.

Referenced by ExecFindMatchingSubPlans().

◆ FormPartitionKeyDatum()

static void FormPartitionKeyDatum	(	PartitionDispatch	pd,
		TupleTableSlot *	slot,
		EState *	estate,
		Datum *	values,
		bool *	isnull
	)

static

Definition at line 1292 of file execPartition.c.

 {
     ListCell   *partexpr_item;
     int         i;
  
     if (pd->key->partexprs != NIL && pd->keystate == NIL)
     {
         /* Check caller has set up context correctly */
         Assert(estate != NULL &&
                GetPerTupleExprContext(estate)->ecxt_scantuple == slot);
  
         /* First time through, set up expression evaluation state */
         pd->keystate = ExecPrepareExprList(pd->key->partexprs, estate);
     }
  
     partexpr_item = list_head(pd->keystate);
     for (i = 0; i < pd->key->partnatts; i++)
     {
         AttrNumber  keycol = pd->key->partattrs[i];
         Datum       datum;
         bool        isNull;
  
         if (keycol != 0)
         {
             /* Plain column; get the value directly from the heap tuple */
             datum = slot_getattr(slot, keycol, &isNull);
         }
         else
         {
             /* Expression; need to evaluate it */
             if (partexpr_item == NULL)
                 elog(ERROR, "wrong number of partition key expressions");
             datum = ExecEvalExprSwitchContext((ExprState *) lfirst(partexpr_item),
                                               GetPerTupleExprContext(estate),
                                               &isNull);
             partexpr_item = lnext(pd->keystate, partexpr_item);
         }
         values[i] = datum;
         isnull[i] = isNull;
     }
  
     if (partexpr_item != NULL)
         elog(ERROR, "wrong number of partition key expressions");
 }

References Assert, elog, ERROR, ExecEvalExprSwitchContext(), ExecPrepareExprList(), GetPerTupleExprContext, i, PartitionDispatchData::key, PartitionDispatchData::keystate, lfirst, list_head(), lnext(), NIL, PartitionKeyData::partattrs, PartitionKeyData::partexprs, PartitionKeyData::partnatts, slot_getattr(), and values.

Referenced by ExecFindPartition().

◆ get_partition_for_tuple()

static int get_partition_for_tuple	(	PartitionDispatch	pd,
		Datum *	values,
		bool *	isnull
	)

static

Definition at line 1389 of file execPartition.c.

 {
     int         bound_offset = -1;
     int         part_index = -1;
     PartitionKey key = pd->key;
     PartitionDesc partdesc = pd->partdesc;
     PartitionBoundInfo boundinfo = partdesc->boundinfo;
  
     /*
      * In the switch statement below, when we perform a cached lookup for
      * RANGE and LIST partitioned tables, if we find that the last found
      * partition matches the 'values', we return the partition index right
      * away.  We do this instead of breaking out of the switch as we don't
      * want to execute the code about the DEFAULT partition or do any updates
      * for any of the cache-related fields.  That would be a waste of effort
      * as we already know it's not the DEFAULT partition and have no need to
      * increment the number of times we found the same partition any higher
      * than PARTITION_CACHED_FIND_THRESHOLD.
      */
  
     /* Route as appropriate based on partitioning strategy. */
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_HASH:
             {
                 uint64      rowHash;
  
                 /* hash partitioning is too cheap to bother caching */
                 rowHash = compute_partition_hash_value(key->partnatts,
                                                        key->partsupfunc,
                                                        key->partcollation,
                                                        values, isnull);
  
                 /*
                  * HASH partitions can't have a DEFAULT partition and we don't
                  * do any caching work for them, so just return the part index
                  */
                 return boundinfo->indexes[rowHash % boundinfo->nindexes];
             }
  
         case PARTITION_STRATEGY_LIST:
             if (isnull[0])
             {
                 /* this is far too cheap to bother doing any caching */
                 if (partition_bound_accepts_nulls(boundinfo))
                 {
                     /*
                      * When there is a NULL partition we just return that
                      * directly.  We don't have a bound_offset so it's not
                      * valid to drop into the code after the switch which
                      * checks and updates the cache fields.  We perhaps should
                      * be invalidating the details of the last cached
                      * partition but there's no real need to.  Keeping those
                      * fields set gives a chance at matching to the cached
                      * partition on the next lookup.
                      */
                     return boundinfo->null_index;
                 }
             }
             else
             {
                 bool        equal;
  
                 if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
                 {
                     int         last_datum_offset = partdesc->last_found_datum_index;
                     Datum       lastDatum = boundinfo->datums[last_datum_offset][0];
                     int32       cmpval;
  
                     /* does the last found datum index match this datum? */
                     cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
                                                              key->partcollation[0],
                                                              lastDatum,
                                                              values[0]));
  
                     if (cmpval == 0)
                         return boundinfo->indexes[last_datum_offset];
  
                     /* fall-through and do a manual lookup */
                 }
  
                 bound_offset = partition_list_bsearch(key->partsupfunc,
                                                       key->partcollation,
                                                       boundinfo,
                                                       values[0], &equal);
                 if (bound_offset >= 0 && equal)
                     part_index = boundinfo->indexes[bound_offset];
             }
             break;
  
         case PARTITION_STRATEGY_RANGE:
             {
                 bool        equal = false,
                             range_partkey_has_null = false;
                 int         i;
  
                 /*
                  * No range includes NULL, so this will be accepted by the
                  * default partition if there is one, and otherwise rejected.
                  */
                 for (i = 0; i < key->partnatts; i++)
                 {
                     if (isnull[i])
                     {
                         range_partkey_has_null = true;
                         break;
                     }
                 }
  
                 /* NULLs belong in the DEFAULT partition */
                 if (range_partkey_has_null)
                     break;
  
                 if (partdesc->last_found_count >= PARTITION_CACHED_FIND_THRESHOLD)
                 {
                     int         last_datum_offset = partdesc->last_found_datum_index;
                     Datum      *lastDatums = boundinfo->datums[last_datum_offset];
                     PartitionRangeDatumKind *kind = boundinfo->kind[last_datum_offset];
                     int32       cmpval;
  
                     /* check if the value is >= to the lower bound */
                     cmpval = partition_rbound_datum_cmp(key->partsupfunc,
                                                         key->partcollation,
                                                         lastDatums,
                                                         kind,
                                                         values,
                                                         key->partnatts);
  
                     /*
                      * If it's equal to the lower bound then no need to check
                      * the upper bound.
                      */
                     if (cmpval == 0)
                         return boundinfo->indexes[last_datum_offset + 1];
  
                     if (cmpval < 0 && last_datum_offset + 1 < boundinfo->ndatums)
                     {
                         /* check if the value is below the upper bound */
                         lastDatums = boundinfo->datums[last_datum_offset + 1];
                         kind = boundinfo->kind[last_datum_offset + 1];
                         cmpval = partition_rbound_datum_cmp(key->partsupfunc,
                                                             key->partcollation,
                                                             lastDatums,
                                                             kind,
                                                             values,
                                                             key->partnatts);
  
                         if (cmpval > 0)
                             return boundinfo->indexes[last_datum_offset + 1];
                     }
                     /* fall-through and do a manual lookup */
                 }
  
                 bound_offset = partition_range_datum_bsearch(key->partsupfunc,
                                                              key->partcollation,
                                                              boundinfo,
                                                              key->partnatts,
                                                              values,
                                                              &equal);
  
                 /*
                  * The bound at bound_offset is less than or equal to the
                  * tuple value, so the bound at offset+1 is the upper bound of
                  * the partition we're looking for, if there actually exists
                  * one.
                  */
                 part_index = boundinfo->indexes[bound_offset + 1];
             }
             break;
  
         default:
             elog(ERROR, "unexpected partition strategy: %d",
                  (int) key->strategy);
     }
  
     /*
      * part_index < 0 means we failed to find a partition of this parent. Use
      * the default partition, if there is one.
      */
     if (part_index < 0)
     {
         /*
          * No need to reset the cache fields here.  The next set of values
          * might end up belonging to the cached partition, so leaving the
          * cache alone improves the chances of a cache hit on the next lookup.
          */
         return boundinfo->default_index;
     }
  
     /* we should only make it here when the code above set bound_offset */
     Assert(bound_offset >= 0);
  
     /*
      * Attend to the cache fields.  If the bound_offset matches the last
      * cached bound offset then we've found the same partition as last time,
      * so bump the count by one.  If all goes well, we'll eventually reach
      * PARTITION_CACHED_FIND_THRESHOLD and try the cache path next time
      * around.  Otherwise, we'll reset the cache count back to 1 to mark that
      * we've found this partition for the first time.
      */
     if (bound_offset == partdesc->last_found_datum_index)
         partdesc->last_found_count++;
     else
     {
         partdesc->last_found_count = 1;
         partdesc->last_found_part_index = part_index;
         partdesc->last_found_datum_index = bound_offset;
     }
  
     return part_index;
 }

References Assert, PartitionDescData::boundinfo, compute_partition_hash_value(), DatumGetInt32(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, elog, equal(), ERROR, FunctionCall2Coll(), i, PartitionBoundInfoData::indexes, PartitionDispatchData::key, sort-test::key, PartitionBoundInfoData::kind, PartitionDescData::last_found_count, PartitionDescData::last_found_datum_index, PartitionDescData::last_found_part_index, PartitionBoundInfoData::ndatums, PartitionBoundInfoData::nindexes, PartitionBoundInfoData::null_index, PartitionDispatchData::partdesc, partition_bound_accepts_nulls, PARTITION_CACHED_FIND_THRESHOLD, partition_list_bsearch(), partition_range_datum_bsearch(), partition_rbound_datum_cmp(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and values.

Referenced by ExecFindPartition().

◆ InitPartitionPruneContext()

static void InitPartitionPruneContext	(	PartitionPruneContext *	context,
		List *	pruning_steps,
		PartitionDesc	partdesc,
		PartitionKey	partkey,
		PlanState *	planstate,
		ExprContext *	econtext
	)

static

Definition at line 2085 of file execPartition.c.

 {
     int         n_steps;
     int         partnatts;
     ListCell   *lc;
  
     n_steps = list_length(pruning_steps);
  
     context->strategy = partkey->strategy;
     context->partnatts = partnatts = partkey->partnatts;
     context->nparts = partdesc->nparts;
     context->boundinfo = partdesc->boundinfo;
     context->partcollation = partkey->partcollation;
     context->partsupfunc = partkey->partsupfunc;
  
     /* We'll look up type-specific support functions as needed */
     context->stepcmpfuncs = (FmgrInfo *)
         palloc0(sizeof(FmgrInfo) * n_steps * partnatts);
  
     context->ppccontext = CurrentMemoryContext;
     context->planstate = planstate;
     context->exprcontext = econtext;
  
     /* Initialize expression state for each expression we need */
     context->exprstates = (ExprState **)
         palloc0(sizeof(ExprState *) * n_steps * partnatts);
     foreach(lc, pruning_steps)
     {
         PartitionPruneStepOp *step = (PartitionPruneStepOp *) lfirst(lc);
         ListCell   *lc2 = list_head(step->exprs);
         int         keyno;
  
         /* not needed for other step kinds */
         if (!IsA(step, PartitionPruneStepOp))
             continue;
  
         Assert(list_length(step->exprs) <= partnatts);
  
         for (keyno = 0; keyno < partnatts; keyno++)
         {
             if (bms_is_member(keyno, step->nullkeys))
                 continue;
  
             if (lc2 != NULL)
             {
                 Expr       *expr = lfirst(lc2);
  
                 /* not needed for Consts */
                 if (!IsA(expr, Const))
                 {
                     int         stateidx = PruneCxtStateIdx(partnatts,
                                                             step->step.step_id,
                                                             keyno);
  
                     /*
                      * When planstate is NULL, pruning_steps is known not to
                      * contain any expressions that depend on the parent plan.
                      * Information of any available EXTERN parameters must be
                      * passed explicitly in that case, which the caller must
                      * have made available via econtext.
                      */
                     if (planstate == NULL)
                         context->exprstates[stateidx] =
                             ExecInitExprWithParams(expr,
                                                    econtext->ecxt_param_list_info);
                     else
                         context->exprstates[stateidx] =
                             ExecInitExpr(expr, context->planstate);
                 }
                 lc2 = lnext(step->exprs, lc2);
             }
         }
     }
 }

References Assert, bms_is_member(), PartitionDescData::boundinfo, context, CurrentMemoryContext, ExprContext::ecxt_param_list_info, ExecInitExpr(), ExecInitExprWithParams(), PartitionPruneStepOp::exprs, IsA, lfirst, list_head(), list_length(), lnext(), PartitionDescData::nparts, PartitionPruneStepOp::nullkeys, palloc0(), PartitionKeyData::partcollation, PartitionKeyData::partnatts, PartitionKeyData::partsupfunc, PruneCxtStateIdx, PartitionPruneStepOp::step, PartitionPruneStep::step_id, and PartitionKeyData::strategy.

Referenced by CreatePartitionPruneState().

◆ PartitionPruneFixSubPlanMap()

static void PartitionPruneFixSubPlanMap	(	PartitionPruneState *	prunestate,
		Bitmapset *	initially_valid_subplans,
		int	n_total_subplans
	)

static

Definition at line 2180 of file execPartition.c.

 {
     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) * n_total_subplans);
     newidx = 1;
     i = -1;
     while ((i = bms_next_member(initially_valid_subplans, i)) >= 0)
     {
         Assert(i < n_total_subplans);
         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 < n_total_subplans);
                     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);
 }

References Assert, bms_add_member(), bms_free(), bms_is_empty, bms_next_member(), i, j, PartitionedRelPruningData::nparts, PartitionPruneState::num_partprunedata, PartitionPruningData::num_partrelprunedata, PartitionPruneState::other_subplans, palloc0(), PartitionPruneState::partprunedata, PartitionPruningData::partrelprunedata, pfree(), PartitionedRelPruningData::present_parts, PartitionedRelPruningData::subpart_map, and PartitionedRelPruningData::subplan_map.

Referenced by ExecInitPartitionPruning().

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ PARTITION_CACHED_FIND_THRESHOLD

Typedef Documentation

◆ PartitionDispatchData

Function Documentation

◆ adjust_partition_colnos()

◆ adjust_partition_colnos_using_map()

◆ CreatePartitionPruneState()

◆ ExecBuildSlotPartitionKeyDescription()

◆ ExecCleanupTupleRouting()

◆ ExecFindMatchingSubPlans()

◆ ExecFindPartition()

◆ ExecInitPartitionDispatchInfo()

◆ ExecInitPartitionInfo()

◆ ExecInitPartitionPruning()

◆ ExecInitRoutingInfo()

◆ ExecSetupPartitionTupleRouting()

◆ find_matching_subplans_recurse()

◆ FormPartitionKeyDatum()

◆ get_partition_for_tuple()

◆ InitPartitionPruneContext()

◆ PartitionPruneFixSubPlanMap()