#include "postgres.h"
#include "pgpa_join.h"
#include "pgpa_planner.h"
#include "pgpa_scan.h"
#include "pgpa_walker.h"
#include "nodes/plannodes.h"
#include "parser/parsetree.h"
#include "utils/lsyscache.h"

Include dependency graph for pgpa_walker.c:

Functions
static void	pgpa_walk_recursively (pgpa_plan_walker_context walker, Plan plan, bool within_join_problem, pgpa_join_unroller join_unroller, List active_query_features, bool beneath_any_gather)

static Bitmapset *	pgpa_process_unrolled_join (pgpa_plan_walker_context walker, pgpa_unrolled_join ujoin)

static pgpa_query_feature *	pgpa_add_feature (pgpa_plan_walker_context walker, pgpa_qf_type type, Plan plan)

static void	pgpa_qf_add_rti (List *active_query_features, Index rti)

static void	pgpa_qf_add_rtis (List active_query_features, Bitmapset relids)

static void	pgpa_qf_add_plan_rtis (List active_query_features, Plan plan, List *rtable)

static bool	pgpa_walker_join_order_matches (pgpa_unrolled_join ujoin, Index rtable_length, pgpa_identifier rt_identifiers, pgpa_advice_target *target, bool toplevel)

static bool	pgpa_walker_join_order_matches_member (pgpa_join_member member, Index rtable_length, pgpa_identifier rt_identifiers, pgpa_advice_target *target)

static pgpa_scan *	pgpa_walker_find_scan (pgpa_plan_walker_context walker, pgpa_scan_strategy strategy, Bitmapset relids)

static bool	pgpa_walker_index_target_matches_plan (pgpa_index_target itarget, Plan plan)

static bool	pgpa_walker_contains_feature (pgpa_plan_walker_context walker, pgpa_qf_type type, Bitmapset relids)

static bool	pgpa_walker_contains_join (pgpa_plan_walker_context walker, pgpa_join_strategy strategy, Bitmapset relids)

static bool	pgpa_walker_contains_no_gather (pgpa_plan_walker_context walker, Bitmapset relids)

static void	pgpa_classify_alternative_subplans (pgpa_plan_walker_context walker, List proots, List chosen_proots, List discarded_proots)

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)

Function Documentation

◆ pgpa_add_feature()

static pgpa_query_feature * pgpa_add_feature	(	pgpa_plan_walker_context *	walker,
		pgpa_qf_type	type,
		Plan *	plan
	)

static

Definition at line 637 of file pgpa_walker.c.

{
    pgpa_query_feature *qf = palloc0_object(pgpa_query_feature);
 
    qf->type = type;
    qf->plan = plan;
 
    walker->query_features[qf->type] =
        lappend(walker->query_features[qf->type], qf);
 
    return qf;
}

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

Referenced by pgpa_add_future_feature(), and pgpa_walk_recursively().

◆ pgpa_add_future_feature()

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

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_classify_alternative_subplans()

static void pgpa_classify_alternative_subplans	(	pgpa_plan_walker_context *	walker,
		List *	proots,
		List **	chosen_proots,
		List **	discarded_proots
	)

static

Definition at line 1094 of file pgpa_walker.c.

{
    Bitmapset  *all_scan_rtis = NULL;
 
    /* Initialize both output lists to empty. */
    *chosen_proots = NIL;
    *discarded_proots = NIL;
 
    /* Collect all scan RTIs. */
    for (int s = 0; s < NUM_PGPA_SCAN_STRATEGY; s++)
        foreach_ptr(pgpa_scan, scan, walker->scans[s])
            all_scan_rtis = bms_add_members(all_scan_rtis, scan->relids);
 
    /* Now classify each subplan. */
    foreach_ptr(pgpa_planner_info, proot, proots)
    {
        bool        chosen = false;
 
        /*
         * We're only interested in classifying subplans for which there are
         * alternatives.
         */
        if (!proot->is_alternative_plan)
            continue;
 
        /*
         * A subplan has been chosen if any of its scan RTIs appear in the
         * final plan. This cannot be the case if it has no RT offset.
         */
        if (proot->has_rtoffset)
        {
            for (int rti = 1; rti <= proot->rid_array_size; rti++)
            {
                if (proot->rid_array[rti - 1].alias_name != NULL &&
                    bms_is_member(proot->rtoffset + rti, all_scan_rtis))
                {
                    chosen = true;
                    break;
                }
            }
        }
 
        /* Add it to the correct list. */
        if (chosen)
            *chosen_proots = lappend(*chosen_proots, proot);
        else
            *discarded_proots = lappend(*discarded_proots, proot);
    }
}

References bms_add_members(), bms_is_member(), fb(), foreach_ptr, lappend(), NIL, and NUM_PGPA_SCAN_STRATEGY.

Referenced by pgpa_plan_walker().

◆ pgpa_filter_out_join_relids()

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

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
	)

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
	)

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_process_unrolled_join()

static Bitmapset * pgpa_process_unrolled_join	(	pgpa_plan_walker_context *	walker,
		pgpa_unrolled_join *	ujoin
	)

static

Definition at line 496 of file pgpa_walker.c.

{
    Bitmapset  *all_relids = bms_copy(ujoin->outer.scan->relids);
 
    /* If this fails, we didn't unroll properly. */
    Assert(ujoin->outer.unrolled_join == NULL);
 
    for (int k = 0; k < ujoin->ninner; ++k)
    {
        pgpa_join_member *member = &ujoin->inner[k];
        Bitmapset  *relids;
 
        if (member->unrolled_join != NULL)
            relids = pgpa_process_unrolled_join(walker,
                                                member->unrolled_join);
        else
        {
            Assert(member->scan != NULL);
            relids = member->scan->relids;
        }
        walker->join_strategies[ujoin->strategy[k]] =
            lappend(walker->join_strategies[ujoin->strategy[k]], relids);
        all_relids = bms_add_members(all_relids, relids);
    }
 
    return all_relids;
}

References Assert, bms_add_members(), bms_copy(), fb(), lappend(), pgpa_process_unrolled_join(), pgpa_scan::relids, pgpa_join_member::scan, and pgpa_join_member::unrolled_join.

Referenced by pgpa_process_unrolled_join(), and pgpa_walk_recursively().

◆ pgpa_qf_add_plan_rtis()

static void pgpa_qf_add_plan_rtis	(	List *	active_query_features,
		Plan *	plan,
		List *	rtable
	)

static

Definition at line 680 of file pgpa_walker.c.

{
    Bitmapset  *relids;
    Index       rti;
 
    if ((relids = pgpa_relids(plan)) != NULL)
    {
        relids = pgpa_filter_out_join_relids(relids, rtable);
        pgpa_qf_add_rtis(active_query_features, relids);
    }
    else if ((rti = pgpa_scanrelid(plan)) != 0)
        pgpa_qf_add_rti(active_query_features, rti);
}

References fb(), pgpa_filter_out_join_relids(), pgpa_qf_add_rti(), pgpa_qf_add_rtis(), pgpa_relids(), pgpa_scanrelid(), and plan.

Referenced by pgpa_walk_recursively().

◆ pgpa_qf_add_rti()

static void pgpa_qf_add_rti	(	List *	active_query_features,
		Index	rti
	)

static

Definition at line 655 of file pgpa_walker.c.

{
    foreach_ptr(pgpa_query_feature, qf, active_query_features)
    {
        qf->relids = bms_add_member(qf->relids, rti);
    }
}

References bms_add_member(), fb(), and foreach_ptr.

Referenced by pgpa_qf_add_plan_rtis().

◆ pgpa_qf_add_rtis()

static void pgpa_qf_add_rtis	(	List *	active_query_features,
		Bitmapset *	relids
	)

static

Definition at line 667 of file pgpa_walker.c.

{
    foreach_ptr(pgpa_query_feature, qf, active_query_features)
    {
        qf->relids = bms_add_members(qf->relids, relids);
    }
}

References bms_add_members(), fb(), and foreach_ptr.

Referenced by pgpa_qf_add_plan_rtis(), and pgpa_walk_recursively().

◆ pgpa_relids()

Bitmapset * pgpa_relids ( Plan * plan )

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 )

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_walk_recursively()

static void pgpa_walk_recursively	(	pgpa_plan_walker_context *	walker,
		Plan *	plan,
		bool	within_join_problem,
		pgpa_join_unroller *	join_unroller,
		List *	active_query_features,
		bool	beneath_any_gather
	)

static

Definition at line 245 of file pgpa_walker.c.

{
    pgpa_join_unroller *outer_join_unroller = NULL;
    pgpa_join_unroller *inner_join_unroller = NULL;
    bool        join_unroller_toplevel = false;
    ListCell   *lc;
    List       *extraplans = NIL;
    List       *elided_nodes = NIL;
 
    Assert(within_join_problem || join_unroller == NULL);
 
    /*
     * Check the future_query_features list to see whether this was previously
     * identified as a plan node that needs to be treated as a query feature.
     * We must do this before handling elided nodes, because if there's an
     * elided node associated with a future query feature, the RTIs associated
     * with the elided node should be the only ones attributed to the query
     * feature.
     */
    foreach_ptr(pgpa_query_feature, qf, walker->future_query_features)
    {
        if (qf->plan == plan)
        {
            active_query_features = list_copy(active_query_features);
            active_query_features = lappend(active_query_features, qf);
            walker->future_query_features =
                list_delete_ptr(walker->future_query_features, qf);
            break;
        }
    }
 
    /*
     * Find all elided nodes for this Plan node.
     */
    foreach_node(ElidedNode, n, walker->pstmt->elidedNodes)
    {
        if (n->plan_node_id == plan->plan_node_id)
            elided_nodes = lappend(elided_nodes, n);
    }
 
    /* If we found any elided_nodes, handle them. */
    if (elided_nodes != NIL)
    {
        int         num_elided_nodes = list_length(elided_nodes);
        ElidedNode *last_elided_node;
 
        /*
         * RTIs for the final -- and thus logically uppermost -- elided node
         * should be collected for query features passed down by the caller.
         * However, elided nodes act as barriers to query features, which
         * means that (1) the remaining elided nodes, if any, should be
         * ignored for purposes of query features and (2) the list of active
         * query features should be reset to empty so that we do not add RTIs
         * from the plan node that is logically beneath the elided node to the
         * query features passed down from the caller.
         */
        last_elided_node = list_nth(elided_nodes, num_elided_nodes - 1);
        pgpa_qf_add_rtis(active_query_features,
                         pgpa_filter_out_join_relids(last_elided_node->relids,
                                                     walker->pstmt->rtable));
        active_query_features = NIL;
 
        /*
         * If we're within a join problem, the join_unroller is responsible
         * for building the scan for the final elided node, so throw it out.
         */
        if (within_join_problem)
            elided_nodes = list_truncate(elided_nodes, num_elided_nodes - 1);
 
        /* Build scans for all (or the remaining) elided nodes. */
        foreach_node(ElidedNode, elided_node, elided_nodes)
        {
            (void) pgpa_build_scan(walker, plan, elided_node,
                                   beneath_any_gather, within_join_problem);
        }
 
        /*
         * If there were any elided nodes, then everything beneath those nodes
         * is not part of the same join problem.
         *
         * In more detail, if an Append or MergeAppend was elided, then a
         * partitionwise join was chosen and only a single child survived; if
         * a SubqueryScan was elided, the subquery was planned without
         * flattening it into the parent.
         */
        within_join_problem = false;
        join_unroller = NULL;
    }
 
    /*
     * If this is a Gather or Gather Merge node, directly add it to the list
     * of currently-active query features. We must do this after handling
     * elided nodes, since the Gather or Gather Merge node occurs logically
     * beneath any associated elided nodes.
     *
     * Exception: We disregard any single_copy Gather nodes. These are created
     * by debug_parallel_query, and having them affect the plan advice is
     * counterproductive, as the result will be to advise the use of a real
     * Gather node, rather than a single copy one.
     */
    if (IsA(plan, Gather) && !((Gather *) plan)->single_copy)
    {
        active_query_features =
            lappend(list_copy(active_query_features),
                    pgpa_add_feature(walker, PGPAQF_GATHER, plan));
        beneath_any_gather = true;
    }
    else if (IsA(plan, GatherMerge))
    {
        active_query_features =
            lappend(list_copy(active_query_features),
                    pgpa_add_feature(walker, PGPAQF_GATHER_MERGE, plan));
        beneath_any_gather = true;
    }
 
    /*
     * If we're within a join problem, the join unroller is responsible for
     * building any required scan for this node. If not, we do it here.
     */
    if (!within_join_problem)
        (void) pgpa_build_scan(walker, plan, NULL, beneath_any_gather, false);
 
    /*
     * If this join needs to be unrolled but there's no join unroller already
     * available, create one.
     */
    if (join_unroller == NULL && pgpa_is_join(plan))
    {
        join_unroller = pgpa_create_join_unroller();
        join_unroller_toplevel = true;
        within_join_problem = true;
    }
 
    /*
     * If this join is to be unrolled, pgpa_unroll_join() will return the join
     * unroller object that should be passed down when we recurse into the
     * outer and inner sides of the plan.
     */
    if (join_unroller != NULL)
        pgpa_unroll_join(walker, plan, beneath_any_gather, join_unroller,
                         &outer_join_unroller, &inner_join_unroller);
 
    /* Add RTIs from the plan node to all active query features. */
    pgpa_qf_add_plan_rtis(active_query_features, plan, walker->pstmt->rtable);
 
    /*
     * Recurse into the outer and inner subtrees.
     *
     * As an exception, if this is a ForeignScan, don't recurse. postgres_fdw
     * sometimes stores an EPQ recheck plan in plan->lefttree, but that's
     * going to mention the same set of relations as the ForeignScan itself,
     * and we have no way to emit advice targeting the EPQ case vs. the
     * non-EPQ case. Moreover, it's not entirely clear what other FDWs might
     * do with the left and right subtrees. Maybe some better handling is
     * needed here, but for now, we just punt.
     */
    if (!IsA(plan, ForeignScan))
    {
        if (plan->lefttree != NULL)
            pgpa_walk_recursively(walker, plan->lefttree, within_join_problem,
                                  outer_join_unroller, active_query_features,
                                  beneath_any_gather);
        if (plan->righttree != NULL)
            pgpa_walk_recursively(walker, plan->righttree, within_join_problem,
                                  inner_join_unroller, active_query_features,
                                  beneath_any_gather);
    }
 
    /*
     * If we created a join unroller up above, then it's also our join to use
     * it to build the final pgpa_unrolled_join, and to destroy the object.
     */
    if (join_unroller_toplevel)
    {
        pgpa_unrolled_join *ujoin;
 
        ujoin = pgpa_build_unrolled_join(walker, join_unroller);
        walker->toplevel_unrolled_joins =
            lappend(walker->toplevel_unrolled_joins, ujoin);
        pgpa_destroy_join_unroller(join_unroller);
        (void) pgpa_process_unrolled_join(walker, ujoin);
    }
 
    /*
     * Some plan types can have additional children. Nodes like Append that
     * can have any number of children store them in a List; a SubqueryScan
     * just has a field for a single additional Plan.
     */
    switch (nodeTag(plan))
    {
        case T_Append:
            {
                Append     *aplan = (Append *) plan;
 
                extraplans = aplan->appendplans;
            }
            break;
        case T_MergeAppend:
            {
                MergeAppend *maplan = (MergeAppend *) plan;
 
                extraplans = maplan->mergeplans;
            }
            break;
        case T_BitmapAnd:
            extraplans = ((BitmapAnd *) plan)->bitmapplans;
            break;
        case T_BitmapOr:
            extraplans = ((BitmapOr *) plan)->bitmapplans;
            break;
        case T_SubqueryScan:
 
            /*
             * We don't pass down active_query_features across here, because
             * those are specific to a subquery level.
             */
            pgpa_walk_recursively(walker, ((SubqueryScan *) plan)->subplan,
                                  0, NULL, NIL, beneath_any_gather);
            break;
        case T_CustomScan:
            extraplans = ((CustomScan *) plan)->custom_plans;
            break;
        default:
            break;
    }
 
    /* If we found a list of extra children, iterate over it. */
    foreach(lc, extraplans)
    {
        Plan       *subplan = lfirst(lc);
 
        pgpa_walk_recursively(walker, subplan, false, NULL, NIL,
                              beneath_any_gather);
    }
}

References Append::appendplans, Assert, fb(), foreach_node, foreach_ptr, IsA, lappend(), lfirst, list_copy(), list_delete_ptr(), list_length(), list_nth(), list_truncate(), MergeAppend::mergeplans, NIL, nodeTag, pgpa_add_feature(), pgpa_build_scan(), pgpa_build_unrolled_join(), pgpa_create_join_unroller(), pgpa_destroy_join_unroller(), pgpa_filter_out_join_relids(), pgpa_is_join(), pgpa_process_unrolled_join(), pgpa_qf_add_plan_rtis(), pgpa_qf_add_rtis(), pgpa_unroll_join(), pgpa_walk_recursively(), PGPAQF_GATHER, PGPAQF_GATHER_MERGE, and plan.

Referenced by pgpa_plan_walker(), and pgpa_walk_recursively().

◆ pgpa_walker_contains_feature()

static bool pgpa_walker_contains_feature	(	pgpa_plan_walker_context *	walker,
		pgpa_qf_type	type,
		Bitmapset *	relids
	)

static

Definition at line 1045 of file pgpa_walker.c.

{
    List       *query_features = walker->query_features[type];
 
    foreach_ptr(pgpa_query_feature, qf, query_features)
    {
        if (bms_equal(qf->relids, relids))
            return true;
    }
 
    return false;
}

References bms_equal(), fb(), foreach_ptr, and type.

Referenced by pgpa_walker_would_advise().

◆ pgpa_walker_contains_join()

static bool pgpa_walker_contains_join	(	pgpa_plan_walker_context *	walker,
		pgpa_join_strategy	strategy,
		Bitmapset *	relids
	)

static

Definition at line 1065 of file pgpa_walker.c.

{
    List       *join_strategies = walker->join_strategies[strategy];
 
    foreach_ptr(Bitmapset, jsrelids, join_strategies)
    {
        if (bms_equal(jsrelids, relids))
            return true;
    }
 
    return false;
}

References bms_equal(), fb(), and foreach_ptr.

Referenced by pgpa_walker_would_advise().

◆ pgpa_walker_contains_no_gather()

static bool pgpa_walker_contains_no_gather	(	pgpa_plan_walker_context *	walker,
		Bitmapset *	relids
	)

static

Definition at line 1084 of file pgpa_walker.c.

{
    return bms_is_subset(relids, walker->no_gather_scans);
}

References bms_is_subset(), and fb().

Referenced by pgpa_walker_would_advise().

◆ pgpa_walker_find_scan()

static pgpa_scan * pgpa_walker_find_scan	(	pgpa_plan_walker_context *	walker,
		pgpa_scan_strategy	strategy,
		Bitmapset *	relids
	)

static

Definition at line 1025 of file pgpa_walker.c.

{
    List       *scans = walker->scans[strategy];
 
    foreach_ptr(pgpa_scan, scan, scans)
    {
        if (bms_equal(scan->relids, relids))
            return scan;
    }
 
    return NULL;
}

References bms_equal(), fb(), and foreach_ptr.

Referenced by pgpa_walker_would_advise().

◆ pgpa_walker_index_target_matches_plan()

static bool pgpa_walker_index_target_matches_plan	(	pgpa_index_target *	itarget,
		Plan *	plan
	)

static

Definition at line 882 of file pgpa_walker.c.

{
    Oid         indexoid = InvalidOid;
 
    /* Retrieve the index OID from the plan. */
    if (IsA(plan, IndexScan))
        indexoid = ((IndexScan *) plan)->indexid;
    else if (IsA(plan, IndexOnlyScan))
        indexoid = ((IndexOnlyScan *) plan)->indexid;
    else
        elog(ERROR, "unrecognized node type: %d", (int) nodeTag(plan));
 
    /* Check whether schema name matches, if specified in index target. */
    if (itarget->indnamespace != NULL)
    {
        Oid         nspoid = get_rel_namespace(indexoid);
        char       *relnamespace = get_namespace_name_or_temp(nspoid);
 
        if (strcmp(itarget->indnamespace, relnamespace) != 0)
            return false;
    }
 
    /* Check whether relation name matches. */
    return (strcmp(itarget->indname, get_rel_name(indexoid)) == 0);
}

References elog, ERROR, fb(), get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), pgpa_index_target::indname, pgpa_index_target::indnamespace, InvalidOid, IsA, nodeTag, and plan.

Referenced by pgpa_walker_would_advise().

◆ pgpa_walker_join_order_matches()

static bool pgpa_walker_join_order_matches	(	pgpa_unrolled_join *	ujoin,
		Index	rtable_length,
		pgpa_identifier *	rt_identifiers,
		pgpa_advice_target *	target,
		bool	toplevel
	)

static

Definition at line 912 of file pgpa_walker.c.

{
    int         nchildren = list_length(target->children);
 
    Assert(target->ttype == PGPA_TARGET_ORDERED_LIST);
 
    /* At toplevel, we allow a prefix match. */
    if (toplevel)
    {
        if (nchildren > ujoin->ninner + 1)
            return false;
    }
    else
    {
        if (nchildren != ujoin->ninner + 1)
            return false;
    }
 
    /* Outermost rel must match. */
    if (!pgpa_walker_join_order_matches_member(&ujoin->outer,
                                               rtable_length,
                                               rt_identifiers,
                                               linitial(target->children)))
        return false;
 
    /* Each inner rel must match. */
    for (int n = 0; n < nchildren - 1; ++n)
    {
        pgpa_advice_target *child_target = list_nth(target->children, n + 1);
 
        if (!pgpa_walker_join_order_matches_member(&ujoin->inner[n],
                                                   rtable_length,
                                                   rt_identifiers,
                                                   child_target))
            return false;
    }
 
    return true;
}

References Assert, pgpa_advice_target::children, fb(), linitial, list_length(), list_nth(), PGPA_TARGET_ORDERED_LIST, pgpa_walker_join_order_matches_member(), and pgpa_advice_target::ttype.

Referenced by pgpa_walker_join_order_matches_member(), and pgpa_walker_would_advise().

◆ pgpa_walker_join_order_matches_member()

static bool pgpa_walker_join_order_matches_member	(	pgpa_join_member *	member,
		Index	rtable_length,
		pgpa_identifier *	rt_identifiers,
		pgpa_advice_target *	target
	)

static

Definition at line 960 of file pgpa_walker.c.

{
    Bitmapset  *relids = NULL;
 
    if (member->unrolled_join != NULL)
    {
        if (target->ttype != PGPA_TARGET_ORDERED_LIST)
            return false;
        return pgpa_walker_join_order_matches(member->unrolled_join,
                                              rtable_length,
                                              rt_identifiers,
                                              target,
                                              false);
    }
 
    Assert(member->scan != NULL);
    switch (target->ttype)
    {
        case PGPA_TARGET_ORDERED_LIST:
            /* Could only match an unrolled join */
            return false;
 
        case PGPA_TARGET_UNORDERED_LIST:
            {
                foreach_ptr(pgpa_advice_target, child_target, target->children)
                {
                    Index       rti;
 
                    rti = pgpa_compute_rti_from_identifier(rtable_length,
                                                           rt_identifiers,
                                                           &child_target->rid);
                    if (rti == 0)
                        return false;
                    relids = bms_add_member(relids, rti);
                }
                break;
            }
 
        case 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);
                break;
            }
    }
 
    return bms_equal(member->scan->relids, relids);
}

References Assert, bms_add_member(), bms_equal(), bms_make_singleton(), pgpa_advice_target::children, fb(), foreach_ptr, pgpa_compute_rti_from_identifier(), PGPA_TARGET_IDENTIFIER, PGPA_TARGET_ORDERED_LIST, PGPA_TARGET_UNORDERED_LIST, pgpa_walker_join_order_matches(), pgpa_scan::relids, pgpa_advice_target::rid, pgpa_join_member::scan, pgpa_advice_target::ttype, and pgpa_join_member::unrolled_join.

Referenced by pgpa_walker_join_order_matches().

◆ 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
	)

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().

Functions

Function Documentation

◆ pgpa_add_feature()

◆ pgpa_add_future_feature()

◆ pgpa_classify_alternative_subplans()

◆ pgpa_filter_out_join_relids()

◆ pgpa_last_elided_node()

◆ pgpa_plan_walker()

◆ pgpa_process_unrolled_join()

◆ pgpa_qf_add_plan_rtis()

◆ pgpa_qf_add_rti()

◆ pgpa_qf_add_rtis()

◆ pgpa_relids()

◆ pgpa_scanrelid()

◆ pgpa_walk_recursively()

◆ 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()

◆ pgpa_walker_join_order_matches_member()

◆ pgpa_walker_would_advise()