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_sj_unique_rel
struct	pgpa_query_feature
struct	pgpa_plan_walker_context

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

Typedefs
typedef struct pgpa_sj_unique_rel	pgpa_sj_unique_rel
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 *sj_unique_rels)
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 70 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

pgpa_sj_unique_rel

typedef struct pgpa_sj_unique_rel pgpa_sj_unique_rel

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 61 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 502 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 585 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 518 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 *  sj_unique_rels  )

extern

Definition at line 71 of file pgpa_walker.c.

{
    ListCell   *lc;
    List       *sj_unique_rtis = NULL;
    List       *sj_nonunique_qfs = NULL;
 
    /* 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_sj_unique_rel, ur, sj_unique_rels)
    {
        int         rtindex = -1;
        int         rtoffset = 0;
        bool        dummy = false;
        Bitmapset  *relids = NULL;
 
        /* If this is a subplan, find the range table offset. */
        if (ur->plan_name != NULL)
        {
            foreach_node(SubPlanRTInfo, rtinfo, pstmt->subrtinfos)
            {
                if (strcmp(ur->plan_name, rtinfo->plan_name) == 0)
                {
                    rtoffset = rtinfo->rtoffset;
                    dummy = rtinfo->dummy;
                    break;
                }
            }
 
            if (rtoffset == 0)
                elog(ERROR, "no rtoffset for plan %s", ur->plan_name);
        }
 
        /* If this entry pertains to a dummy subquery, ignore it. */
        if (dummy)
            continue;
 
        /* Offset each entry from the original set. */
        while ((rtindex = bms_next_member(ur->relids, rtindex)) >= 0)
            relids = bms_add_member(relids, rtindex + rtoffset);
 
        /* Store the resulting set. */
        sj_unique_rtis = lappend(sj_unique_rtis, 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;
    }
}

References 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_walk_recursively(), PGPAQF_GATHER, PGPAQF_GATHER_MERGE, PGPAQF_SEMIJOIN_NON_UNIQUE, PGPAQF_SEMIJOIN_UNIQUE, plan, PlannedStmt::planTree, PlannedStmt::subplans, and PlannedStmt::subrtinfos.

Referenced by pgpa_planner_shutdown().

pgpa_relids()

Bitmapset * pgpa_relids ( Plan *  plan )

extern

Definition at line 535 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 555 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 672 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;
    }
 
    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_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 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(), 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_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_advice_target::rid, and pgpa_advice_target::ttype.

Referenced by pgpa_planner_append_feedback().