pgpa_walker.h File Reference

#include "pgpa_ast.h"
#include "pgpa_join.h"
#include "pgpa_scan.h"

Include dependency graph for pgpa_walker.h:

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

Go to the source code of this file.

Data Structures
struct	pgpa_query_feature
struct	pgpa_plan_walker_context

Macros
#define	NUM_PGPA_QF_TYPES   ((int) PGPAQF_SEMIJOIN_UNIQUE + 1)

Typedefs
typedef enum pgpa_qf_type	pgpa_qf_type
typedef struct pgpa_query_feature	pgpa_query_feature
typedef struct pgpa_plan_walker_context	pgpa_plan_walker_context

Enumerations
enum	pgpa_qf_type { PGPAQF_GATHER , PGPAQF_GATHER_MERGE , PGPAQF_SEMIJOIN_NON_UNIQUE , PGPAQF_SEMIJOIN_UNIQUE }

Functions
void	pgpa_plan_walker (pgpa_plan_walker_context *walker, PlannedStmt *pstmt, List *proots)
void	pgpa_add_future_feature (pgpa_plan_walker_context *walker, pgpa_qf_type type, Plan *plan)
ElidedNode *	pgpa_last_elided_node (PlannedStmt *pstmt, Plan *plan)
Bitmapset *	pgpa_relids (Plan *plan)
Index	pgpa_scanrelid (Plan *plan)
Bitmapset *	pgpa_filter_out_join_relids (Bitmapset *relids, List *rtable)
bool	pgpa_walker_would_advise (pgpa_plan_walker_context *walker, pgpa_identifier *rt_identifiers, pgpa_advice_tag_type tag, pgpa_advice_target *target)

Macro Definition Documentation

NUM_PGPA_QF_TYPES

#define NUM_PGPA_QF_TYPES   ((int) PGPAQF_SEMIJOIN_UNIQUE + 1)

Definition at line 52 of file pgpa_walker.h.

Typedef Documentation

pgpa_plan_walker_context

typedef struct pgpa_plan_walker_context pgpa_plan_walker_context

pgpa_qf_type

typedef enum pgpa_qf_type pgpa_qf_type

pgpa_query_feature

typedef struct pgpa_query_feature pgpa_query_feature

Enumeration Type Documentation

pgpa_qf_type

enum pgpa_qf_type

Enumerator
PGPAQF_GATHER
PGPAQF_GATHER_MERGE
PGPAQF_SEMIJOIN_NON_UNIQUE
PGPAQF_SEMIJOIN_UNIQUE

Definition at line 43 of file pgpa_walker.h.

{
    PGPAQF_GATHER,
    PGPAQF_GATHER_MERGE,
    PGPAQF_SEMIJOIN_NON_UNIQUE,
    PGPAQF_SEMIJOIN_UNIQUE
    /* update NUM_PGPA_QF_TYPES if you add anything here */
} pgpa_qf_type;

Function Documentation

pgpa_add_future_feature()

void pgpa_add_future_feature ( pgpa_plan_walker_context *  walker, pgpa_qf_type  type, Plan *  plan  )

extern

Definition at line 533 of file pgpa_walker.c.

{
    pgpa_query_feature *qf = pgpa_add_feature(walker, type, plan);
 
    walker->future_query_features =
        lappend(walker->future_query_features, qf);
}

References fb(), lappend(), pgpa_add_feature(), plan, and type.

Referenced by pgpa_decompose_join().

pgpa_filter_out_join_relids()

Bitmapset * pgpa_filter_out_join_relids ( Bitmapset *  relids, List *  rtable  )

extern

Definition at line 616 of file pgpa_walker.c.

{
    int         rti = -1;
    Bitmapset  *result = NULL;
 
    while ((rti = bms_next_member(relids, rti)) >= 0)
    {
        RangeTblEntry *rte = rt_fetch(rti, rtable);
 
        if (rte->rtekind != RTE_JOIN)
            result = bms_add_member(result, rti);
    }
 
    return result;
}

References bms_add_member(), bms_next_member(), fb(), rt_fetch, and RTE_JOIN.

Referenced by pgpa_build_scan(), pgpa_qf_add_plan_rtis(), and pgpa_walk_recursively().

pgpa_last_elided_node()

ElidedNode * pgpa_last_elided_node ( PlannedStmt *  pstmt, Plan *  plan  )

extern

Definition at line 549 of file pgpa_walker.c.

{
    ElidedNode *elided_node = NULL;
 
    foreach_node(ElidedNode, n, pstmt->elidedNodes)
    {
        if (n->plan_node_id == plan->plan_node_id)
            elided_node = n;
    }
 
    return elided_node;
}

References PlannedStmt::elidedNodes, fb(), foreach_node, and plan.

Referenced by pgpa_decompose_join(), and pgpa_descend_node().

pgpa_plan_walker()

void pgpa_plan_walker ( pgpa_plan_walker_context *  walker, PlannedStmt *  pstmt, List *  proots  )

extern

Definition at line 76 of file pgpa_walker.c.

{
    ListCell   *lc;
    List       *sj_unique_rtis = NULL;
    List       *sj_nonunique_qfs = NULL;
    List       *chosen_proots;
    List       *discarded_proots;
 
    /* Initialization. */
    memset(walker, 0, sizeof(pgpa_plan_walker_context));
    walker->pstmt = pstmt;
 
    /* Walk the main plan tree. */
    pgpa_walk_recursively(walker, pstmt->planTree, false, NULL, NIL, false);
 
    /* Main plan tree walk won't reach subplans, so walk those. */
    foreach(lc, pstmt->subplans)
    {
        Plan       *plan = lfirst(lc);
 
        if (plan != NULL)
            pgpa_walk_recursively(walker, plan, false, NULL, NIL, false);
    }
 
    /* Adjust RTIs from sj_unique_rels for the flattened range table. */
    foreach_ptr(pgpa_planner_info, proot, proots)
    {
        /* If there are no sj_unique_rels for this proot, we can skip it. */
        if (proot->sj_unique_rels == NIL)
            continue;
 
        /* If this is a subplan, find the range table offset. */
        if (!proot->has_rtoffset)
            elog(ERROR, "no rtoffset for plan %s", proot->plan_name);
 
        /* Offset each relid set by the proot's rtoffset. */
        foreach_node(Bitmapset, relids, proot->sj_unique_rels)
        {
            int         rtindex = -1;
            Bitmapset  *flat_relids = NULL;
 
            while ((rtindex = bms_next_member(relids, rtindex)) >= 0)
                flat_relids = bms_add_member(flat_relids,
                                             rtindex + proot->rtoffset);
 
            sj_unique_rtis = lappend(sj_unique_rtis, flat_relids);
        }
    }
 
    /*
     * Remove any non-unique semijoin query features for which making the rel
     * unique wasn't considered.
     */
    foreach_ptr(pgpa_query_feature, qf,
                walker->query_features[PGPAQF_SEMIJOIN_NON_UNIQUE])
    {
        if (list_member(sj_unique_rtis, qf->relids))
            sj_nonunique_qfs = lappend(sj_nonunique_qfs, qf);
    }
    walker->query_features[PGPAQF_SEMIJOIN_NON_UNIQUE] = sj_nonunique_qfs;
 
    /*
     * If we find any cases where analysis of the Plan tree shows that the
     * semijoin was made unique but this possibility was never observed to be
     * considered during planning, then we have a bug somewhere.
     */
    foreach_ptr(pgpa_query_feature, qf,
                walker->query_features[PGPAQF_SEMIJOIN_UNIQUE])
    {
        if (!list_member(sj_unique_rtis, qf->relids))
        {
            StringInfoData buf;
 
            initStringInfo(&buf);
            outBitmapset(&buf, qf->relids);
            elog(ERROR,
                 "unique semijoin found for relids %s but not observed during planning",
                 buf.data);
        }
    }
 
    /*
     * It's possible for a Gather or Gather Merge query feature to find no
     * RTIs when partitionwise aggregation is in use. We shouldn't emit
     * something like GATHER_MERGE(()), so instead emit nothing. This means
     * that we won't advise either GATHER or GATHER_MERGE or NO_GATHER in such
     * cases, which might be something we want to improve in the future.
     *
     * (Should the Partial Aggregates in such a case be created in an
     * UPPERREL_GROUP_AGG with a non-empty relid set? Right now that doesn't
     * happen, but it seems like it would make life easier for us if it did.)
     */
    for (int t = 0; t < NUM_PGPA_QF_TYPES; ++t)
    {
        List       *query_features = NIL;
 
        foreach_ptr(pgpa_query_feature, qf, walker->query_features[t])
        {
            if (qf->relids != NULL)
                query_features = lappend(query_features, qf);
            else
                Assert(t == PGPAQF_GATHER || t == PGPAQF_GATHER_MERGE);
        }
 
        walker->query_features[t] = query_features;
    }
 
    /* Classify alternative subplans. */
    pgpa_classify_alternative_subplans(walker, proots,
                                       &chosen_proots, &discarded_proots);
 
    /*
     * Figure out which of the discarded alternatives have a non-discarded
     * alternative. Those are the ones for which we want to emit DO_NOT_SCAN
     * advice. (If every alternative was discarded, then there's no point.)
     */
    foreach_ptr(pgpa_planner_info, discarded_proot, discarded_proots)
    {
        bool        some_alternative_chosen = false;
 
        foreach_ptr(pgpa_planner_info, chosen_proot, chosen_proots)
        {
            if (strings_equal_or_both_null(discarded_proot->alternative_plan_name,
                                           chosen_proot->alternative_plan_name))
            {
                some_alternative_chosen = true;
                break;
            }
        }
 
        if (some_alternative_chosen)
        {
            for (int rti = 1; rti <= discarded_proot->rid_array_size; rti++)
            {
                pgpa_identifier *rid = &discarded_proot->rid_array[rti - 1];
 
                if (rid->alias_name != NULL)
                    walker->do_not_scan_identifiers =
                        lappend(walker->do_not_scan_identifiers, rid);
            }
        }
    }
}

References pgpa_identifier::alias_name, Assert, bms_add_member(), bms_next_member(), buf, elog, ERROR, fb(), foreach_node, foreach_ptr, initStringInfo(), lappend(), lfirst, list_member(), NIL, NUM_PGPA_QF_TYPES, outBitmapset(), pgpa_classify_alternative_subplans(), pgpa_walk_recursively(), PGPAQF_GATHER, PGPAQF_GATHER_MERGE, PGPAQF_SEMIJOIN_NON_UNIQUE, PGPAQF_SEMIJOIN_UNIQUE, plan, PlannedStmt::planTree, strings_equal_or_both_null(), and PlannedStmt::subplans.

Referenced by pgpa_planner_shutdown().

pgpa_relids()

Bitmapset * pgpa_relids ( Plan *  plan )

extern

Definition at line 566 of file pgpa_walker.c.

{
    if (IsA(plan, Result))
        return ((Result *) plan)->relids;
    else if (IsA(plan, ForeignScan))
        return ((ForeignScan *) plan)->fs_relids;
    else if (IsA(plan, Append))
        return ((Append *) plan)->apprelids;
    else if (IsA(plan, MergeAppend))
        return ((MergeAppend *) plan)->apprelids;
 
    return NULL;
}

References fb(), IsA, and plan.

Referenced by pgpa_build_scan(), and pgpa_qf_add_plan_rtis().

pgpa_scanrelid()

Index pgpa_scanrelid ( Plan *  plan )

extern

Definition at line 586 of file pgpa_walker.c.

{
    switch (nodeTag(plan))
    {
        case T_SeqScan:
        case T_SampleScan:
        case T_BitmapHeapScan:
        case T_TidScan:
        case T_TidRangeScan:
        case T_SubqueryScan:
        case T_FunctionScan:
        case T_TableFuncScan:
        case T_ValuesScan:
        case T_CteScan:
        case T_NamedTuplestoreScan:
        case T_WorkTableScan:
        case T_ForeignScan:
        case T_CustomScan:
        case T_IndexScan:
        case T_IndexOnlyScan:
            return ((Scan *) plan)->scanrelid;
        default:
            return 0;
    }
}

References fb(), nodeTag, and plan.

Referenced by pgpa_build_scan(), and pgpa_qf_add_plan_rtis().

pgpa_walker_would_advise()

bool pgpa_walker_would_advise ( pgpa_plan_walker_context *  walker, pgpa_identifier *  rt_identifiers, pgpa_advice_tag_type  tag, pgpa_advice_target *  target  )

extern

Definition at line 703 of file pgpa_walker.c.

{
    Index       rtable_length = list_length(walker->pstmt->rtable);
    Bitmapset  *relids = NULL;
 
    if (tag == PGPA_TAG_JOIN_ORDER)
    {
        foreach_ptr(pgpa_unrolled_join, ujoin, walker->toplevel_unrolled_joins)
        {
            if (pgpa_walker_join_order_matches(ujoin, rtable_length,
                                               rt_identifiers, target, true))
                return true;
        }
 
        return false;
    }
 
    /*
     * DO_NOT_SCAN advice targets rels that may not be in the flat range table
     * (e.g. MinMaxAgg losers), so pgpa_compute_rti_from_identifier won't work
     * here. Instead, check directly against the do_not_scan_identifiers list.
     */
    if (tag == PGPA_TAG_DO_NOT_SCAN)
    {
        if (target->ttype != PGPA_TARGET_IDENTIFIER)
            return false;
        foreach_ptr(pgpa_identifier, rid, walker->do_not_scan_identifiers)
        {
            if (strcmp(rid->alias_name, target->rid.alias_name) == 0 &&
                rid->occurrence == target->rid.occurrence &&
                strings_equal_or_both_null(rid->partnsp,
                                           target->rid.partnsp) &&
                strings_equal_or_both_null(rid->partrel,
                                           target->rid.partrel) &&
                strings_equal_or_both_null(rid->plan_name,
                                           target->rid.plan_name))
                return true;
        }
        return false;
    }
 
    if (target->ttype == PGPA_TARGET_IDENTIFIER)
    {
        Index       rti;
 
        rti = pgpa_compute_rti_from_identifier(rtable_length, rt_identifiers,
                                               &target->rid);
        if (rti == 0)
            return false;
        relids = bms_make_singleton(rti);
    }
    else
    {
        Assert(target->ttype == PGPA_TARGET_ORDERED_LIST);
        foreach_ptr(pgpa_advice_target, child_target, target->children)
        {
            Index       rti;
 
            Assert(child_target->ttype == PGPA_TARGET_IDENTIFIER);
            rti = pgpa_compute_rti_from_identifier(rtable_length,
                                                   rt_identifiers,
                                                   &child_target->rid);
            if (rti == 0)
                return false;
            relids = bms_add_member(relids, rti);
        }
    }
 
    switch (tag)
    {
        case PGPA_TAG_JOIN_ORDER:
            /* should have been handled above */
            pg_unreachable();
            break;
        case PGPA_TAG_DO_NOT_SCAN:
            /* should have been handled above */
            pg_unreachable();
            break;
        case PGPA_TAG_BITMAP_HEAP_SCAN:
            return pgpa_walker_find_scan(walker,
                                         PGPA_SCAN_BITMAP_HEAP,
                                         relids) != NULL;
        case PGPA_TAG_FOREIGN_JOIN:
            return pgpa_walker_find_scan(walker,
                                         PGPA_SCAN_FOREIGN,
                                         relids) != NULL;
        case PGPA_TAG_INDEX_ONLY_SCAN:
            {
                pgpa_scan  *scan;
 
                scan = pgpa_walker_find_scan(walker, PGPA_SCAN_INDEX_ONLY,
                                             relids);
                if (scan == NULL)
                    return false;
 
                return pgpa_walker_index_target_matches_plan(target->itarget, scan->plan);
            }
        case PGPA_TAG_INDEX_SCAN:
            {
                pgpa_scan  *scan;
 
                scan = pgpa_walker_find_scan(walker, PGPA_SCAN_INDEX,
                                             relids);
                if (scan == NULL)
                    return false;
 
                return pgpa_walker_index_target_matches_plan(target->itarget, scan->plan);
            }
        case PGPA_TAG_PARTITIONWISE:
            return pgpa_walker_find_scan(walker,
                                         PGPA_SCAN_PARTITIONWISE,
                                         relids) != NULL;
        case PGPA_TAG_SEQ_SCAN:
            return pgpa_walker_find_scan(walker,
                                         PGPA_SCAN_SEQ,
                                         relids) != NULL;
        case PGPA_TAG_TID_SCAN:
            return pgpa_walker_find_scan(walker,
                                         PGPA_SCAN_TID,
                                         relids) != NULL;
        case PGPA_TAG_GATHER:
            return pgpa_walker_contains_feature(walker,
                                                PGPAQF_GATHER,
                                                relids);
        case PGPA_TAG_GATHER_MERGE:
            return pgpa_walker_contains_feature(walker,
                                                PGPAQF_GATHER_MERGE,
                                                relids);
        case PGPA_TAG_SEMIJOIN_NON_UNIQUE:
            return pgpa_walker_contains_feature(walker,
                                                PGPAQF_SEMIJOIN_NON_UNIQUE,
                                                relids);
        case PGPA_TAG_SEMIJOIN_UNIQUE:
            return pgpa_walker_contains_feature(walker,
                                                PGPAQF_SEMIJOIN_UNIQUE,
                                                relids);
        case PGPA_TAG_HASH_JOIN:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_HASH_JOIN,
                                             relids);
        case PGPA_TAG_MERGE_JOIN_MATERIALIZE:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_MERGE_JOIN_MATERIALIZE,
                                             relids);
        case PGPA_TAG_MERGE_JOIN_PLAIN:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_MERGE_JOIN_PLAIN,
                                             relids);
        case PGPA_TAG_NESTED_LOOP_MATERIALIZE:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_NESTED_LOOP_MATERIALIZE,
                                             relids);
        case PGPA_TAG_NESTED_LOOP_MEMOIZE:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_NESTED_LOOP_MEMOIZE,
                                             relids);
        case PGPA_TAG_NESTED_LOOP_PLAIN:
            return pgpa_walker_contains_join(walker,
                                             JSTRAT_NESTED_LOOP_PLAIN,
                                             relids);
        case PGPA_TAG_NO_GATHER:
            return pgpa_walker_contains_no_gather(walker, relids);
    }
 
    /* should not get here */
    return false;
}

References pgpa_identifier::alias_name, Assert, bms_add_member(), bms_make_singleton(), pgpa_advice_target::children, fb(), foreach_ptr, pgpa_advice_target::itarget, JSTRAT_HASH_JOIN, JSTRAT_MERGE_JOIN_MATERIALIZE, JSTRAT_MERGE_JOIN_PLAIN, JSTRAT_NESTED_LOOP_MATERIALIZE, JSTRAT_NESTED_LOOP_MEMOIZE, JSTRAT_NESTED_LOOP_PLAIN, list_length(), pgpa_identifier::occurrence, pgpa_identifier::partnsp, pgpa_identifier::partrel, pg_unreachable, pgpa_compute_rti_from_identifier(), PGPA_SCAN_BITMAP_HEAP, PGPA_SCAN_FOREIGN, PGPA_SCAN_INDEX, PGPA_SCAN_INDEX_ONLY, PGPA_SCAN_PARTITIONWISE, PGPA_SCAN_SEQ, PGPA_SCAN_TID, PGPA_TAG_BITMAP_HEAP_SCAN, PGPA_TAG_DO_NOT_SCAN, PGPA_TAG_FOREIGN_JOIN, PGPA_TAG_GATHER, PGPA_TAG_GATHER_MERGE, PGPA_TAG_HASH_JOIN, PGPA_TAG_INDEX_ONLY_SCAN, PGPA_TAG_INDEX_SCAN, PGPA_TAG_JOIN_ORDER, PGPA_TAG_MERGE_JOIN_MATERIALIZE, PGPA_TAG_MERGE_JOIN_PLAIN, PGPA_TAG_NESTED_LOOP_MATERIALIZE, PGPA_TAG_NESTED_LOOP_MEMOIZE, PGPA_TAG_NESTED_LOOP_PLAIN, PGPA_TAG_NO_GATHER, PGPA_TAG_PARTITIONWISE, PGPA_TAG_SEMIJOIN_NON_UNIQUE, PGPA_TAG_SEMIJOIN_UNIQUE, PGPA_TAG_SEQ_SCAN, PGPA_TAG_TID_SCAN, PGPA_TARGET_IDENTIFIER, PGPA_TARGET_ORDERED_LIST, pgpa_walker_contains_feature(), pgpa_walker_contains_join(), pgpa_walker_contains_no_gather(), pgpa_walker_find_scan(), pgpa_walker_index_target_matches_plan(), pgpa_walker_join_order_matches(), PGPAQF_GATHER, PGPAQF_GATHER_MERGE, PGPAQF_SEMIJOIN_NON_UNIQUE, PGPAQF_SEMIJOIN_UNIQUE, pgpa_scan::plan, pgpa_identifier::plan_name, pgpa_advice_target::rid, strings_equal_or_both_null(), and pgpa_advice_target::ttype.

Referenced by pgpa_planner_append_feedback().