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 PlannerInfo	PlannerInfo
typedef struct RelOptInfo	RelOptInfo
typedef struct PartitionPruneContext	PartitionPruneContext

Functions
int	make_partition_pruneinfo (PlannerInfo *root, RelOptInfo *parentrel, List *subpaths, List *prunequal)
Bitmapset *	prune_append_rel_partitions (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

PlannerInfo

typedef struct PlannerInfo PlannerInfo

Definition at line 20 of file partprune.h.

RelOptInfo

typedef struct RelOptInfo RelOptInfo

Definition at line 21 of file partprune.h.

Function Documentation

get_matching_partitions()

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

extern

Definition at line 846 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(), PartitionPruneContext::boundinfo, PartitionBoundInfoData::default_index, elog, ERROR, fb(), 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(), result, PartitionPruneStep::step_id, and PartitionPruneContext::strategy.

Referenced by find_matching_subplans_recurse(), and prune_append_rel_partitions().

make_partition_pruneinfo()

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

extern

Definition at line 225 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_array(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 -1;
 
    /* Else build the result data structure */
    pruneinfo = makeNode(PartitionPruneInfo);
    pruneinfo->relids = bms_copy(parentrel->relids);
    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;
 
    root->partPruneInfos = lappend(root->partPruneInfos, pruneinfo);
 
    return list_length(root->partPruneInfos) - 1;
}

References add_part_relids(), Assert, bms_add_member(), bms_add_range(), bms_copy(), bms_del_members(), bms_join(), bms_num_members(), fb(), find_base_rel(), i, IS_PARTITIONED_REL, lappend(), lfirst, list_length(), make_partitionedrel_pruneinfo(), makeNode, NIL, palloc0_array, pfree(), RELOPT_OTHER_MEMBER_REL, and root.

Referenced by create_append_plan(), and create_merge_append_plan().

prune_append_rel_partitions()

Bitmapset * prune_append_rel_partitions ( RelOptInfo *  rel )

extern

Definition at line 780 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 = palloc0_array(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, fb(), gen_partprune_steps(), get_matching_partitions(), list_length(), NIL, RelOptInfo::nparts, PartitionPruneContext::nparts, palloc0_array, PartitionPruneContext::partcollation, PartitionPruneContext::partnatts, PartitionPruneContext::partsupfunc, PARTTARGET_PLANNER, PartitionPruneContext::planstate, PartitionPruneContext::ppccontext, PartitionPruneContext::stepcmpfuncs, GeneratePruningStepsContext::steps, and PartitionPruneContext::strategy.

Referenced by expand_partitioned_rtentry().