partprune.h File Reference

#include "nodes/execnodes.h"
#include "partitioning/partdefs.h"

Include dependency graph for partprune.h:

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

Go to the source code of this file.

Data Structures
struct	PartitionPruneContext

Macros
#define	PruneCxtStateIdx(partnatts, step_id, keyno)    ((partnatts) * (step_id) + (keyno))

Typedefs
typedef struct PartitionPruneContext	PartitionPruneContext

Functions
PartitionPruneInfo *	make_partition_pruneinfo (struct PlannerInfo *root, struct RelOptInfo *parentrel, List *subpaths, List *prunequal)
Bitmapset *	prune_append_rel_partitions (struct RelOptInfo *rel)
Bitmapset *	get_matching_partitions (PartitionPruneContext *context, List *pruning_steps)

Macro Definition Documentation

PruneCxtStateIdx

#define PruneCxtStateIdx	(		partnatts,
			step_id,
			keyno
	)		((partnatts) * (step_id) + (keyno))

Definition at line 70 of file partprune.h.

Typedef Documentation

PartitionPruneContext

typedef struct PartitionPruneContext PartitionPruneContext

Function Documentation

get_matching_partitions()

Bitmapset * get_matching_partitions	(	PartitionPruneContext *	context,
		List *	pruning_steps
	)

Definition at line 817 of file partprune.c.

{
    Bitmapset  *result;
    int         num_steps = list_length(pruning_steps),
                i;
    PruneStepResult **results,
               *final_result;
    ListCell   *lc;
    bool        scan_default;
 
    /* If there are no pruning steps then all partitions match. */
    if (num_steps == 0)
    {
        Assert(context->nparts > 0);
        return bms_add_range(NULL, 0, context->nparts - 1);
    }
 
    /*
     * Allocate space for individual pruning steps to store its result.  Each
     * slot will hold a PruneStepResult after performing a given pruning step.
     * Later steps may use the result of one or more earlier steps.  The
     * result of applying all pruning steps is the value contained in the slot
     * of the last pruning step.
     */
    results = (PruneStepResult **)
        palloc0(num_steps * sizeof(PruneStepResult *));
    foreach(lc, pruning_steps)
    {
        PartitionPruneStep *step = lfirst(lc);
 
        switch (nodeTag(step))
        {
            case T_PartitionPruneStepOp:
                results[step->step_id] =
                    perform_pruning_base_step(context,
                                              (PartitionPruneStepOp *) step);
                break;
 
            case T_PartitionPruneStepCombine:
                results[step->step_id] =
                    perform_pruning_combine_step(context,
                                                 (PartitionPruneStepCombine *) step,
                                                 results);
                break;
 
            default:
                elog(ERROR, "invalid pruning step type: %d",
                     (int) nodeTag(step));
        }
    }
 
    /*
     * At this point we know the offsets of all the datums whose corresponding
     * partitions need to be in the result, including special null-accepting
     * and default partitions.  Collect the actual partition indexes now.
     */
    final_result = results[num_steps - 1];
    Assert(final_result != NULL);
    i = -1;
    result = NULL;
    scan_default = final_result->scan_default;
    while ((i = bms_next_member(final_result->bound_offsets, i)) >= 0)
    {
        int         partindex;
 
        Assert(i < context->boundinfo->nindexes);
        partindex = context->boundinfo->indexes[i];
 
        if (partindex < 0)
        {
            /*
             * In range partitioning cases, if a partition index is -1 it
             * means that the bound at the offset is the upper bound for a
             * range not covered by any partition (other than a possible
             * default partition).  In hash partitioning, the same means no
             * partition has been defined for the corresponding remainder
             * value.
             *
             * In either case, the value is still part of the queried range of
             * values, so mark to scan the default partition if one exists.
             */
            scan_default |= partition_bound_has_default(context->boundinfo);
            continue;
        }
 
        result = bms_add_member(result, partindex);
    }
 
    /* Add the null and/or default partition if needed and present. */
    if (final_result->scan_null)
    {
        Assert(context->strategy == PARTITION_STRATEGY_LIST);
        Assert(partition_bound_accepts_nulls(context->boundinfo));
        result = bms_add_member(result, context->boundinfo->null_index);
    }
    if (scan_default)
    {
        Assert(context->strategy == PARTITION_STRATEGY_LIST ||
               context->strategy == PARTITION_STRATEGY_RANGE);
        Assert(partition_bound_has_default(context->boundinfo));
        result = bms_add_member(result, context->boundinfo->default_index);
    }
 
    return result;
}

References Assert, bms_add_member(), bms_add_range(), bms_next_member(), PruneStepResult::bound_offsets, PartitionPruneContext::boundinfo, PartitionBoundInfoData::default_index, elog, ERROR, i, PartitionBoundInfoData::indexes, lfirst, list_length(), nodeTag, PartitionPruneContext::nparts, PartitionBoundInfoData::null_index, palloc0(), partition_bound_accepts_nulls, partition_bound_has_default, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, perform_pruning_base_step(), perform_pruning_combine_step(), PruneStepResult::scan_default, PruneStepResult::scan_null, PartitionPruneStep::step_id, and PartitionPruneContext::strategy.

Referenced by find_matching_subplans_recurse(), and prune_append_rel_partitions().

make_partition_pruneinfo()

PartitionPruneInfo * make_partition_pruneinfo	(	struct PlannerInfo *	root,
		struct RelOptInfo *	parentrel,
		List *	subpaths,
		List *	prunequal
	)

Definition at line 220 of file partprune.c.

{
    PartitionPruneInfo *pruneinfo;
    Bitmapset  *allmatchedsubplans = NULL;
    List       *allpartrelids;
    List       *prunerelinfos;
    int        *relid_subplan_map;
    ListCell   *lc;
    int         i;
 
    /*
     * Scan the subpaths to see which ones are scans of partition child
     * relations, and identify their parent partitioned rels.  (Note: we must
     * restrict the parent partitioned rels to be parentrel or children of
     * parentrel, otherwise we couldn't translate prunequal to match.)
     *
     * Also construct a temporary array to map from partition-child-relation
     * relid to the index in 'subpaths' of the scan plan for that partition.
     * (Use of "subplan" rather than "subpath" is a bit of a misnomer, but
     * we'll let it stand.)  For convenience, we use 1-based indexes here, so
     * that zero can represent an un-filled array entry.
     */
    allpartrelids = NIL;
    relid_subplan_map = palloc0(sizeof(int) * root->simple_rel_array_size);
 
    i = 1;
    foreach(lc, subpaths)
    {
        Path       *path = (Path *) lfirst(lc);
        RelOptInfo *pathrel = path->parent;
 
        /* We don't consider partitioned joins here */
        if (pathrel->reloptkind == RELOPT_OTHER_MEMBER_REL)
        {
            RelOptInfo *prel = pathrel;
            Bitmapset  *partrelids = NULL;
 
            /*
             * Traverse up to the pathrel's topmost partitioned parent,
             * collecting parent relids as we go; but stop if we reach
             * parentrel.  (Normally, a pathrel's topmost partitioned parent
             * is either parentrel or a UNION ALL appendrel child of
             * parentrel.  But when handling partitionwise joins of
             * multi-level partitioning trees, we can see an append path whose
             * parentrel is an intermediate partitioned table.)
             */
            do
            {
                AppendRelInfo *appinfo;
 
                Assert(prel->relid < root->simple_rel_array_size);
                appinfo = root->append_rel_array[prel->relid];
                prel = find_base_rel(root, appinfo->parent_relid);
                if (!IS_PARTITIONED_REL(prel))
                    break;      /* reached a non-partitioned parent */
                /* accept this level as an interesting parent */
                partrelids = bms_add_member(partrelids, prel->relid);
                if (prel == parentrel)
                    break;      /* don't traverse above parentrel */
            } while (prel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
            if (partrelids)
            {
                /*
                 * Found some relevant parent partitions, which may or may not
                 * overlap with partition trees we already found.  Add new
                 * information to the allpartrelids list.
                 */
                allpartrelids = add_part_relids(allpartrelids, partrelids);
                /* Also record the subplan in relid_subplan_map[] */
                /* No duplicates please */
                Assert(relid_subplan_map[pathrel->relid] == 0);
                relid_subplan_map[pathrel->relid] = i;
            }
        }
        i++;
    }
 
    /*
     * We now build a PartitionedRelPruneInfo for each topmost partitioned rel
     * (omitting any that turn out not to have useful pruning quals).
     */
    prunerelinfos = NIL;
    foreach(lc, allpartrelids)
    {
        Bitmapset  *partrelids = (Bitmapset *) lfirst(lc);
        List       *pinfolist;
        Bitmapset  *matchedsubplans = NULL;
 
        pinfolist = make_partitionedrel_pruneinfo(root, parentrel,
                                                  prunequal,
                                                  partrelids,
                                                  relid_subplan_map,
                                                  &matchedsubplans);
 
        /* When pruning is possible, record the matched subplans */
        if (pinfolist != NIL)
        {
            prunerelinfos = lappend(prunerelinfos, pinfolist);
            allmatchedsubplans = bms_join(matchedsubplans,
                                          allmatchedsubplans);
        }
    }
 
    pfree(relid_subplan_map);
 
    /*
     * If none of the partition hierarchies had any useful run-time pruning
     * quals, then we can just not bother with run-time pruning.
     */
    if (prunerelinfos == NIL)
        return NULL;
 
    /* Else build the result data structure */
    pruneinfo = makeNode(PartitionPruneInfo);
    pruneinfo->prune_infos = prunerelinfos;
 
    /*
     * Some subplans may not belong to any of the identified partitioned rels.
     * This can happen for UNION ALL queries which include a non-partitioned
     * table, or when some of the hierarchies aren't run-time prunable.  Build
     * a bitmapset of the indexes of all such subplans, so that the executor
     * can identify which subplans should never be pruned.
     */
    if (bms_num_members(allmatchedsubplans) < list_length(subpaths))
    {
        Bitmapset  *other_subplans;
 
        /* Create the complement of allmatchedsubplans */
        other_subplans = bms_add_range(NULL, 0, list_length(subpaths) - 1);
        other_subplans = bms_del_members(other_subplans, allmatchedsubplans);
 
        pruneinfo->other_subplans = other_subplans;
    }
    else
        pruneinfo->other_subplans = NULL;
 
    return pruneinfo;
}

References add_part_relids(), Assert, bms_add_member(), bms_add_range(), bms_del_members(), bms_join(), bms_num_members(), find_base_rel(), i, IS_PARTITIONED_REL, lappend(), lfirst, list_length(), make_partitionedrel_pruneinfo(), makeNode, NIL, PartitionPruneInfo::other_subplans, palloc0(), AppendRelInfo::parent_relid, pfree(), PartitionPruneInfo::prune_infos, RelOptInfo::relid, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, and root.

Referenced by create_append_plan(), and create_merge_append_plan().

prune_append_rel_partitions()

Bitmapset * prune_append_rel_partitions

(

struct RelOptInfo *

rel

)

Definition at line 750 of file partprune.c.

{
    List       *clauses = rel->baserestrictinfo;
    List       *pruning_steps;
    GeneratePruningStepsContext gcontext;
    PartitionPruneContext context;
 
    Assert(rel->part_scheme != NULL);
 
    /* If there are no partitions, return the empty set */
    if (rel->nparts == 0)
        return NULL;
 
    /*
     * If pruning is disabled or if there are no clauses to prune with, return
     * all partitions.
     */
    if (!enable_partition_pruning || clauses == NIL)
        return bms_add_range(NULL, 0, rel->nparts - 1);
 
    /*
     * Process clauses to extract pruning steps that are usable at plan time.
     * If the clauses are found to be contradictory, we can return the empty
     * set.
     */
    gen_partprune_steps(rel, clauses, PARTTARGET_PLANNER,
                        &gcontext);
    if (gcontext.contradictory)
        return NULL;
    pruning_steps = gcontext.steps;
 
    /* If there's nothing usable, return all partitions */
    if (pruning_steps == NIL)
        return bms_add_range(NULL, 0, rel->nparts - 1);
 
    /* Set up PartitionPruneContext */
    context.strategy = rel->part_scheme->strategy;
    context.partnatts = rel->part_scheme->partnatts;
    context.nparts = rel->nparts;
    context.boundinfo = rel->boundinfo;
    context.partcollation = rel->part_scheme->partcollation;
    context.partsupfunc = rel->part_scheme->partsupfunc;
    context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
                                                context.partnatts *
                                                list_length(pruning_steps));
    context.ppccontext = CurrentMemoryContext;
 
    /* These are not valid when being called from the planner */
    context.planstate = NULL;
    context.exprcontext = NULL;
    context.exprstates = NULL;
 
    /* Actual pruning happens here. */
    return get_matching_partitions(&context, pruning_steps);
}

References Assert, RelOptInfo::baserestrictinfo, bms_add_range(), PartitionPruneContext::boundinfo, GeneratePruningStepsContext::contradictory, CurrentMemoryContext, enable_partition_pruning, PartitionPruneContext::exprcontext, PartitionPruneContext::exprstates, gen_partprune_steps(), get_matching_partitions(), list_length(), NIL, RelOptInfo::nparts, PartitionPruneContext::nparts, palloc0(), PartitionPruneContext::partcollation, PartitionPruneContext::partnatts, PartitionPruneContext::partsupfunc, PARTTARGET_PLANNER, PartitionPruneContext::planstate, PartitionPruneContext::ppccontext, PartitionPruneContext::stepcmpfuncs, GeneratePruningStepsContext::steps, and PartitionPruneContext::strategy.

Referenced by expand_partitioned_rtentry().