createplan.c File Reference

#include "postgres.h"
#include <math.h>
#include "access/sysattr.h"
#include "catalog/pg_class.h"
#include "foreign/fdwapi.h"
#include "miscadmin.h"
#include "nodes/extensible.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/optimizer.h"
#include "optimizer/paramassign.h"
#include "optimizer/paths.h"
#include "optimizer/placeholder.h"
#include "optimizer/plancat.h"
#include "optimizer/planmain.h"
#include "optimizer/prep.h"
#include "optimizer/restrictinfo.h"
#include "optimizer/subselect.h"
#include "optimizer/tlist.h"
#include "parser/parse_clause.h"
#include "parser/parsetree.h"
#include "partitioning/partprune.h"
#include "utils/lsyscache.h"

Include dependency graph for createplan.c:

Go to the source code of this file.

Macros
#define	CP_EXACT_TLIST   0x0001 /* Plan must return specified tlist */
#define	CP_SMALL_TLIST   0x0002 /* Prefer narrower tlists */
#define	CP_LABEL_TLIST   0x0004 /* tlist must contain sortgrouprefs */
#define	CP_IGNORE_TLIST   0x0008 /* caller will replace tlist */

Functions
static Plan *	create_plan_recurse (PlannerInfo *root, Path *best_path, int flags)
static Plan *	create_scan_plan (PlannerInfo *root, Path *best_path, int flags)
static List *	build_path_tlist (PlannerInfo *root, Path *path)
static bool	use_physical_tlist (PlannerInfo *root, Path *path, int flags)
static List *	get_gating_quals (PlannerInfo *root, List *quals)
static Plan *	create_gating_plan (PlannerInfo *root, Path *path, Plan *plan, List *gating_quals)
static Plan *	create_join_plan (PlannerInfo *root, JoinPath *best_path)
static bool	mark_async_capable_plan (Plan *plan, Path *path)
static Plan *	create_append_plan (PlannerInfo *root, AppendPath *best_path, int flags)
static Plan *	create_merge_append_plan (PlannerInfo *root, MergeAppendPath *best_path, int flags)
static Result *	create_group_result_plan (PlannerInfo *root, GroupResultPath *best_path)
static ProjectSet *	create_project_set_plan (PlannerInfo *root, ProjectSetPath *best_path)
static Material *	create_material_plan (PlannerInfo *root, MaterialPath *best_path, int flags)
static Memoize *	create_memoize_plan (PlannerInfo *root, MemoizePath *best_path, int flags)
static Plan *	create_unique_plan (PlannerInfo *root, UniquePath *best_path, int flags)
static Gather *	create_gather_plan (PlannerInfo *root, GatherPath *best_path)
static Plan *	create_projection_plan (PlannerInfo *root, ProjectionPath *best_path, int flags)
static Plan *	inject_projection_plan (Plan *subplan, List *tlist, bool parallel_safe)
static Sort *	create_sort_plan (PlannerInfo *root, SortPath *best_path, int flags)
static IncrementalSort *	create_incrementalsort_plan (PlannerInfo *root, IncrementalSortPath *best_path, int flags)
static Group *	create_group_plan (PlannerInfo *root, GroupPath *best_path)
static Unique *	create_upper_unique_plan (PlannerInfo *root, UpperUniquePath *best_path, int flags)
static Agg *	create_agg_plan (PlannerInfo *root, AggPath *best_path)
static Plan *	create_groupingsets_plan (PlannerInfo *root, GroupingSetsPath *best_path)
static Result *	create_minmaxagg_plan (PlannerInfo *root, MinMaxAggPath *best_path)
static WindowAgg *	create_windowagg_plan (PlannerInfo *root, WindowAggPath *best_path)
static SetOp *	create_setop_plan (PlannerInfo *root, SetOpPath *best_path, int flags)
static RecursiveUnion *	create_recursiveunion_plan (PlannerInfo *root, RecursiveUnionPath *best_path)
static LockRows *	create_lockrows_plan (PlannerInfo *root, LockRowsPath *best_path, int flags)
static ModifyTable *	create_modifytable_plan (PlannerInfo *root, ModifyTablePath *best_path)
static Limit *	create_limit_plan (PlannerInfo *root, LimitPath *best_path, int flags)
static SeqScan *	create_seqscan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static SampleScan *	create_samplescan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static Scan *	create_indexscan_plan (PlannerInfo *root, IndexPath *best_path, List *tlist, List *scan_clauses, bool indexonly)
static BitmapHeapScan *	create_bitmap_scan_plan (PlannerInfo *root, BitmapHeapPath *best_path, List *tlist, List *scan_clauses)
static Plan *	create_bitmap_subplan (PlannerInfo *root, Path *bitmapqual, List **qual, List **indexqual, List **indexECs)
static void	bitmap_subplan_mark_shared (Plan *plan)
static TidScan *	create_tidscan_plan (PlannerInfo *root, TidPath *best_path, List *tlist, List *scan_clauses)
static TidRangeScan *	create_tidrangescan_plan (PlannerInfo *root, TidRangePath *best_path, List *tlist, List *scan_clauses)
static SubqueryScan *	create_subqueryscan_plan (PlannerInfo *root, SubqueryScanPath *best_path, List *tlist, List *scan_clauses)
static FunctionScan *	create_functionscan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static ValuesScan *	create_valuesscan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static TableFuncScan *	create_tablefuncscan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static CteScan *	create_ctescan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static NamedTuplestoreScan *	create_namedtuplestorescan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static Result *	create_resultscan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static WorkTableScan *	create_worktablescan_plan (PlannerInfo *root, Path *best_path, List *tlist, List *scan_clauses)
static ForeignScan *	create_foreignscan_plan (PlannerInfo *root, ForeignPath *best_path, List *tlist, List *scan_clauses)
static CustomScan *	create_customscan_plan (PlannerInfo *root, CustomPath *best_path, List *tlist, List *scan_clauses)
static NestLoop *	create_nestloop_plan (PlannerInfo *root, NestPath *best_path)
static MergeJoin *	create_mergejoin_plan (PlannerInfo *root, MergePath *best_path)
static HashJoin *	create_hashjoin_plan (PlannerInfo *root, HashPath *best_path)
static Node *	replace_nestloop_params (PlannerInfo *root, Node *expr)
static Node *	replace_nestloop_params_mutator (Node *node, PlannerInfo *root)
static void	fix_indexqual_references (PlannerInfo *root, IndexPath *index_path, List **stripped_indexquals_p, List **fixed_indexquals_p)
static List *	fix_indexorderby_references (PlannerInfo *root, IndexPath *index_path)
static Node *	fix_indexqual_clause (PlannerInfo *root, IndexOptInfo *index, int indexcol, Node *clause, List *indexcolnos)
static Node *	fix_indexqual_operand (Node *node, IndexOptInfo *index, int indexcol)
static List *	get_switched_clauses (List *clauses, Relids outerrelids)
static List *	order_qual_clauses (PlannerInfo *root, List *clauses)
static void	copy_generic_path_info (Plan *dest, Path *src)
static void	copy_plan_costsize (Plan *dest, Plan *src)
static void	label_sort_with_costsize (PlannerInfo *root, Sort *plan, double limit_tuples)
static SeqScan *	make_seqscan (List *qptlist, List *qpqual, Index scanrelid)
static SampleScan *	make_samplescan (List *qptlist, List *qpqual, Index scanrelid, TableSampleClause *tsc)
static IndexScan *	make_indexscan (List *qptlist, List *qpqual, Index scanrelid, Oid indexid, List *indexqual, List *indexqualorig, List *indexorderby, List *indexorderbyorig, List *indexorderbyops, ScanDirection indexscandir)
static IndexOnlyScan *	make_indexonlyscan (List *qptlist, List *qpqual, Index scanrelid, Oid indexid, List *indexqual, List *recheckqual, List *indexorderby, List *indextlist, ScanDirection indexscandir)
static BitmapIndexScan *	make_bitmap_indexscan (Index scanrelid, Oid indexid, List *indexqual, List *indexqualorig)
static BitmapHeapScan *	make_bitmap_heapscan (List *qptlist, List *qpqual, Plan *lefttree, List *bitmapqualorig, Index scanrelid)
static TidScan *	make_tidscan (List *qptlist, List *qpqual, Index scanrelid, List *tidquals)
static TidRangeScan *	make_tidrangescan (List *qptlist, List *qpqual, Index scanrelid, List *tidrangequals)
static SubqueryScan *	make_subqueryscan (List *qptlist, List *qpqual, Index scanrelid, Plan *subplan)
static FunctionScan *	make_functionscan (List *qptlist, List *qpqual, Index scanrelid, List *functions, bool funcordinality)
static ValuesScan *	make_valuesscan (List *qptlist, List *qpqual, Index scanrelid, List *values_lists)
static TableFuncScan *	make_tablefuncscan (List *qptlist, List *qpqual, Index scanrelid, TableFunc *tablefunc)
static CteScan *	make_ctescan (List *qptlist, List *qpqual, Index scanrelid, int ctePlanId, int cteParam)
static NamedTuplestoreScan *	make_namedtuplestorescan (List *qptlist, List *qpqual, Index scanrelid, char *enrname)
static WorkTableScan *	make_worktablescan (List *qptlist, List *qpqual, Index scanrelid, int wtParam)
static RecursiveUnion *	make_recursive_union (List *tlist, Plan *lefttree, Plan *righttree, int wtParam, List *distinctList, long numGroups)
static BitmapAnd *	make_bitmap_and (List *bitmapplans)
static BitmapOr *	make_bitmap_or (List *bitmapplans)
static NestLoop *	make_nestloop (List *tlist, List *joinclauses, List *otherclauses, List *nestParams, Plan *lefttree, Plan *righttree, JoinType jointype, bool inner_unique)
static HashJoin *	make_hashjoin (List *tlist, List *joinclauses, List *otherclauses, List *hashclauses, List *hashoperators, List *hashcollations, List *hashkeys, Plan *lefttree, Plan *righttree, JoinType jointype, bool inner_unique)
static Hash *	make_hash (Plan *lefttree, List *hashkeys, Oid skewTable, AttrNumber skewColumn, bool skewInherit)
static MergeJoin *	make_mergejoin (List *tlist, List *joinclauses, List *otherclauses, List *mergeclauses, Oid *mergefamilies, Oid *mergecollations, int *mergestrategies, bool *mergenullsfirst, Plan *lefttree, Plan *righttree, JoinType jointype, bool inner_unique, bool skip_mark_restore)
static Sort *	make_sort (Plan *lefttree, int numCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst)
static IncrementalSort *	make_incrementalsort (Plan *lefttree, int numCols, int nPresortedCols, AttrNumber *sortColIdx, Oid *sortOperators, Oid *collations, bool *nullsFirst)
static Plan *	prepare_sort_from_pathkeys (Plan *lefttree, List *pathkeys, Relids relids, const AttrNumber *reqColIdx, bool adjust_tlist_in_place, int *p_numsortkeys, AttrNumber **p_sortColIdx, Oid **p_sortOperators, Oid **p_collations, bool **p_nullsFirst)
static Sort *	make_sort_from_pathkeys (Plan *lefttree, List *pathkeys, Relids relids)
static IncrementalSort *	make_incrementalsort_from_pathkeys (Plan *lefttree, List *pathkeys, Relids relids, int nPresortedCols)
static Sort *	make_sort_from_groupcols (List *groupcls, AttrNumber *grpColIdx, Plan *lefttree)
static Material *	make_material (Plan *lefttree)
static Memoize *	make_memoize (Plan *lefttree, Oid *hashoperators, Oid *collations, List *param_exprs, bool singlerow, bool binary_mode, uint32 est_entries, Bitmapset *keyparamids)
static WindowAgg *	make_windowagg (List *tlist, Index winref, int partNumCols, AttrNumber *partColIdx, Oid *partOperators, Oid *partCollations, int ordNumCols, AttrNumber *ordColIdx, Oid *ordOperators, Oid *ordCollations, int frameOptions, Node *startOffset, Node *endOffset, Oid startInRangeFunc, Oid endInRangeFunc, Oid inRangeColl, bool inRangeAsc, bool inRangeNullsFirst, List *runCondition, List *qual, bool topWindow, Plan *lefttree)
static Group *	make_group (List *tlist, List *qual, int numGroupCols, AttrNumber *grpColIdx, Oid *grpOperators, Oid *grpCollations, Plan *lefttree)
static Unique *	make_unique_from_sortclauses (Plan *lefttree, List *distinctList)
static Unique *	make_unique_from_pathkeys (Plan *lefttree, List *pathkeys, int numCols)
static Gather *	make_gather (List *qptlist, List *qpqual, int nworkers, int rescan_param, bool single_copy, Plan *subplan)
static SetOp *	make_setop (SetOpCmd cmd, SetOpStrategy strategy, Plan *lefttree, List *distinctList, AttrNumber flagColIdx, int firstFlag, long numGroups)
static LockRows *	make_lockrows (Plan *lefttree, List *rowMarks, int epqParam)
static Result *	make_result (List *tlist, Node *resconstantqual, Plan *subplan)
static ProjectSet *	make_project_set (List *tlist, Plan *subplan)
static ModifyTable *	make_modifytable (PlannerInfo *root, Plan *subplan, CmdType operation, bool canSetTag, Index nominalRelation, Index rootRelation, bool partColsUpdated, List *resultRelations, List *updateColnosLists, List *withCheckOptionLists, List *returningLists, List *rowMarks, OnConflictExpr *onconflict, List *mergeActionLists, int epqParam)
static GatherMerge *	create_gather_merge_plan (PlannerInfo *root, GatherMergePath *best_path)
Plan *	create_plan (PlannerInfo *root, Path *best_path)
Plan *	change_plan_targetlist (Plan *subplan, List *tlist, bool tlist_parallel_safe)
static AttrNumber *	remap_groupColIdx (PlannerInfo *root, List *groupClause)
ForeignScan *	make_foreignscan (List *qptlist, List *qpqual, Index scanrelid, List *fdw_exprs, List *fdw_private, List *fdw_scan_tlist, List *fdw_recheck_quals, Plan *outer_plan)
Sort *	make_sort_from_sortclauses (List *sortcls, Plan *lefttree)
Plan *	materialize_finished_plan (Plan *subplan)
Agg *	make_agg (List *tlist, List *qual, AggStrategy aggstrategy, AggSplit aggsplit, int numGroupCols, AttrNumber *grpColIdx, Oid *grpOperators, Oid *grpCollations, List *groupingSets, List *chain, double dNumGroups, Size transitionSpace, Plan *lefttree)
Limit *	make_limit (Plan *lefttree, Node *limitOffset, Node *limitCount, LimitOption limitOption, int uniqNumCols, AttrNumber *uniqColIdx, Oid *uniqOperators, Oid *uniqCollations)
bool	is_projection_capable_path (Path *path)
bool	is_projection_capable_plan (Plan *plan)

Macro Definition Documentation

CP_EXACT_TLIST

#define CP_EXACT_TLIST   0x0001 /* Plan must return specified tlist */

Definition at line 68 of file createplan.c.

CP_IGNORE_TLIST

#define CP_IGNORE_TLIST   0x0008 /* caller will replace tlist */

Definition at line 71 of file createplan.c.

CP_LABEL_TLIST

#define CP_LABEL_TLIST   0x0004 /* tlist must contain sortgrouprefs */

Definition at line 70 of file createplan.c.

CP_SMALL_TLIST

#define CP_SMALL_TLIST   0x0002 /* Prefer narrower tlists */

Definition at line 69 of file createplan.c.

Function Documentation

bitmap_subplan_mark_shared()

static void bitmap_subplan_mark_shared ( Plan *  plan )

static

Definition at line 5450 of file createplan.c.

{
    if (IsA(plan, BitmapAnd))
        bitmap_subplan_mark_shared(linitial(((BitmapAnd *) plan)->bitmapplans));
    else if (IsA(plan, BitmapOr))
    {
        ((BitmapOr *) plan)->isshared = true;
        bitmap_subplan_mark_shared(linitial(((BitmapOr *) plan)->bitmapplans));
    }
    else if (IsA(plan, BitmapIndexScan))
        ((BitmapIndexScan *) plan)->isshared = true;
    else
        elog(ERROR, "unrecognized node type: %d", nodeTag(plan));
}

References elog(), ERROR, IsA, linitial, nodeTag, and plan.

Referenced by create_bitmap_scan_plan().

build_path_tlist()

static List * build_path_tlist ( PlannerInfo *  root, Path *  path  )

static

Definition at line 823 of file createplan.c.

{
    List       *tlist = NIL;
    Index      *sortgrouprefs = path->pathtarget->sortgrouprefs;
    int         resno = 1;
    ListCell   *v;
 
    foreach(v, path->pathtarget->exprs)
    {
        Node       *node = (Node *) lfirst(v);
        TargetEntry *tle;
 
        /*
         * If it's a parameterized path, there might be lateral references in
         * the tlist, which need to be replaced with Params.  There's no need
         * to remake the TargetEntry nodes, so apply this to each list item
         * separately.
         */
        if (path->param_info)
            node = replace_nestloop_params(root, node);
 
        tle = makeTargetEntry((Expr *) node,
                              resno,
                              NULL,
                              false);
        if (sortgrouprefs)
            tle->ressortgroupref = sortgrouprefs[resno - 1];
 
        tlist = lappend(tlist, tle);
        resno++;
    }
    return tlist;
}

References lappend(), lfirst, makeTargetEntry(), NIL, replace_nestloop_params(), and TargetEntry::ressortgroupref.

Referenced by create_agg_plan(), create_append_plan(), create_gather_merge_plan(), create_gather_plan(), create_gating_plan(), create_group_plan(), create_group_result_plan(), create_groupingsets_plan(), create_hashjoin_plan(), create_merge_append_plan(), create_mergejoin_plan(), create_minmaxagg_plan(), create_nestloop_plan(), create_project_set_plan(), create_projection_plan(), create_recursiveunion_plan(), create_scan_plan(), create_unique_plan(), and create_windowagg_plan().

change_plan_targetlist()

Plan* change_plan_targetlist	(	Plan *	subplan,
		List *	tlist,
		bool	tlist_parallel_safe
	)

Definition at line 2150 of file createplan.c.

{
    /*
     * If the top plan node can't do projections and its existing target list
     * isn't already what we need, we need to add a Result node to help it
     * along.
     */
    if (!is_projection_capable_plan(subplan) &&
        !tlist_same_exprs(tlist, subplan->targetlist))
        subplan = inject_projection_plan(subplan, tlist,
                                         subplan->parallel_safe &&
                                         tlist_parallel_safe);
    else
    {
        /* Else we can just replace the plan node's tlist */
        subplan->targetlist = tlist;
        subplan->parallel_safe &= tlist_parallel_safe;
    }
    return subplan;
}

References inject_projection_plan(), is_projection_capable_plan(), Plan::parallel_safe, Plan::targetlist, and tlist_same_exprs().

Referenced by create_unique_plan(), and postgresGetForeignPlan().

copy_generic_path_info()

static void copy_generic_path_info ( Plan *  dest, Path *  src  )

static

Definition at line 5381 of file createplan.c.

{
    dest->startup_cost = src->startup_cost;
    dest->total_cost = src->total_cost;
    dest->plan_rows = src->rows;
    dest->plan_width = src->pathtarget->width;
    dest->parallel_aware = src->parallel_aware;
    dest->parallel_safe = src->parallel_safe;
}

References generate_unaccent_rules::dest, Path::parallel_aware, Path::parallel_safe, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by create_agg_plan(), create_append_plan(), create_bitmap_scan_plan(), create_ctescan_plan(), create_customscan_plan(), create_foreignscan_plan(), create_functionscan_plan(), create_gather_merge_plan(), create_gather_plan(), create_group_plan(), create_group_result_plan(), create_groupingsets_plan(), create_hashjoin_plan(), create_incrementalsort_plan(), create_indexscan_plan(), create_limit_plan(), create_lockrows_plan(), create_material_plan(), create_memoize_plan(), create_merge_append_plan(), create_mergejoin_plan(), create_minmaxagg_plan(), create_modifytable_plan(), create_namedtuplestorescan_plan(), create_nestloop_plan(), create_project_set_plan(), create_projection_plan(), create_recursiveunion_plan(), create_resultscan_plan(), create_samplescan_plan(), create_seqscan_plan(), create_setop_plan(), create_sort_plan(), create_subqueryscan_plan(), create_tablefuncscan_plan(), create_tidrangescan_plan(), create_tidscan_plan(), create_unique_plan(), create_upper_unique_plan(), create_valuesscan_plan(), create_windowagg_plan(), and create_worktablescan_plan().

copy_plan_costsize()

static void copy_plan_costsize ( Plan *  dest, Plan *  src  )

static

Definition at line 5396 of file createplan.c.

{
    dest->startup_cost = src->startup_cost;
    dest->total_cost = src->total_cost;
    dest->plan_rows = src->plan_rows;
    dest->plan_width = src->plan_width;
    /* Assume the inserted node is not parallel-aware. */
    dest->parallel_aware = false;
    /* Assume the inserted node is parallel-safe, if child plan is. */
    dest->parallel_safe = src->parallel_safe;
}

References generate_unaccent_rules::dest, Plan::parallel_safe, Plan::plan_rows, Plan::plan_width, Plan::startup_cost, and Plan::total_cost.

Referenced by create_gating_plan(), create_hashjoin_plan(), create_mergejoin_plan(), and inject_projection_plan().

create_agg_plan()

static Agg * create_agg_plan ( PlannerInfo *  root, AggPath *  best_path  )

static

Definition at line 2306 of file createplan.c.

{
    Agg        *plan;
    Plan       *subplan;
    List       *tlist;
    List       *quals;
 
    /*
     * Agg can project, so no need to be terribly picky about child tlist, but
     * we do need grouping columns to be available
     */
    subplan = create_plan_recurse(root, best_path->subpath, CP_LABEL_TLIST);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    quals = order_qual_clauses(root, best_path->qual);
 
    plan = make_agg(tlist, quals,
                    best_path->aggstrategy,
                    best_path->aggsplit,
                    list_length(best_path->groupClause),
                    extract_grouping_cols(best_path->groupClause,
                                          subplan->targetlist),
                    extract_grouping_ops(best_path->groupClause),
                    extract_grouping_collations(best_path->groupClause,
                                                subplan->targetlist),
                    NIL,
                    NIL,
                    best_path->numGroups,
                    best_path->transitionSpace,
                    subplan);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References AggPath::aggsplit, AggPath::aggstrategy, build_path_tlist(), copy_generic_path_info(), CP_LABEL_TLIST, create_plan_recurse(), extract_grouping_collations(), extract_grouping_cols(), extract_grouping_ops(), AggPath::groupClause, list_length(), make_agg(), NIL, AggPath::numGroups, order_qual_clauses(), AggPath::path, plan, AggPath::qual, AggPath::subpath, Plan::targetlist, and AggPath::transitionSpace.

Referenced by create_plan_recurse().

create_append_plan()

static Plan * create_append_plan ( PlannerInfo *  root, AppendPath *  best_path, int  flags  )

static

Definition at line 1214 of file createplan.c.

{
    Append     *plan;
    List       *tlist = build_path_tlist(root, &best_path->path);
    int         orig_tlist_length = list_length(tlist);
    bool        tlist_was_changed = false;
    List       *pathkeys = best_path->path.pathkeys;
    List       *subplans = NIL;
    ListCell   *subpaths;
    int         nasyncplans = 0;
    RelOptInfo *rel = best_path->path.parent;
    PartitionPruneInfo *partpruneinfo = NULL;
    int         nodenumsortkeys = 0;
    AttrNumber *nodeSortColIdx = NULL;
    Oid        *nodeSortOperators = NULL;
    Oid        *nodeCollations = NULL;
    bool       *nodeNullsFirst = NULL;
    bool        consider_async = false;
 
    /*
     * The subpaths list could be empty, if every child was proven empty by
     * constraint exclusion.  In that case generate a dummy plan that returns
     * no rows.
     *
     * Note that an AppendPath with no members is also generated in certain
     * cases where there was no appending construct at all, but we know the
     * relation is empty (see set_dummy_rel_pathlist and mark_dummy_rel).
     */
    if (best_path->subpaths == NIL)
    {
        /* Generate a Result plan with constant-FALSE gating qual */
        Plan       *plan;
 
        plan = (Plan *) make_result(tlist,
                                    (Node *) list_make1(makeBoolConst(false,
                                                                      false)),
                                    NULL);
 
        copy_generic_path_info(plan, (Path *) best_path);
 
        return plan;
    }
 
    /*
     * Otherwise build an Append plan.  Note that if there's just one child,
     * the Append is pretty useless; but we wait till setrefs.c to get rid of
     * it.  Doing so here doesn't work because the varno of the child scan
     * plan won't match the parent-rel Vars it'll be asked to emit.
     *
     * We don't have the actual creation of the Append node split out into a
     * separate make_xxx function.  This is because we want to run
     * prepare_sort_from_pathkeys on it before we do so on the individual
     * child plans, to make cross-checking the sort info easier.
     */
    plan = makeNode(Append);
    plan->plan.targetlist = tlist;
    plan->plan.qual = NIL;
    plan->plan.lefttree = NULL;
    plan->plan.righttree = NULL;
    plan->apprelids = rel->relids;
 
    if (pathkeys != NIL)
    {
        /*
         * Compute sort column info, and adjust the Append's tlist as needed.
         * Because we pass adjust_tlist_in_place = true, we may ignore the
         * function result; it must be the same plan node.  However, we then
         * need to detect whether any tlist entries were added.
         */
        (void) prepare_sort_from_pathkeys((Plan *) plan, pathkeys,
                                          best_path->path.parent->relids,
                                          NULL,
                                          true,
                                          &nodenumsortkeys,
                                          &nodeSortColIdx,
                                          &nodeSortOperators,
                                          &nodeCollations,
                                          &nodeNullsFirst);
        tlist_was_changed = (orig_tlist_length != list_length(plan->plan.targetlist));
    }
 
    /* If appropriate, consider async append */
    consider_async = (enable_async_append && pathkeys == NIL &&
                      !best_path->path.parallel_safe &&
                      list_length(best_path->subpaths) > 1);
 
    /* Build the plan for each child */
    foreach(subpaths, best_path->subpaths)
    {
        Path       *subpath = (Path *) lfirst(subpaths);
        Plan       *subplan;
 
        /* Must insist that all children return the same tlist */
        subplan = create_plan_recurse(root, subpath, CP_EXACT_TLIST);
 
        /*
         * For ordered Appends, we must insert a Sort node if subplan isn't
         * sufficiently ordered.
         */
        if (pathkeys != NIL)
        {
            int         numsortkeys;
            AttrNumber *sortColIdx;
            Oid        *sortOperators;
            Oid        *collations;
            bool       *nullsFirst;
 
            /*
             * Compute sort column info, and adjust subplan's tlist as needed.
             * We must apply prepare_sort_from_pathkeys even to subplans that
             * don't need an explicit sort, to make sure they are returning
             * the same sort key columns the Append expects.
             */
            subplan = prepare_sort_from_pathkeys(subplan, pathkeys,
                                                 subpath->parent->relids,
                                                 nodeSortColIdx,
                                                 false,
                                                 &numsortkeys,
                                                 &sortColIdx,
                                                 &sortOperators,
                                                 &collations,
                                                 &nullsFirst);
 
            /*
             * Check that we got the same sort key information.  We just
             * Assert that the sortops match, since those depend only on the
             * pathkeys; but it seems like a good idea to check the sort
             * column numbers explicitly, to ensure the tlists match up.
             */
            Assert(numsortkeys == nodenumsortkeys);
            if (memcmp(sortColIdx, nodeSortColIdx,
                       numsortkeys * sizeof(AttrNumber)) != 0)
                elog(ERROR, "Append child's targetlist doesn't match Append");
            Assert(memcmp(sortOperators, nodeSortOperators,
                          numsortkeys * sizeof(Oid)) == 0);
            Assert(memcmp(collations, nodeCollations,
                          numsortkeys * sizeof(Oid)) == 0);
            Assert(memcmp(nullsFirst, nodeNullsFirst,
                          numsortkeys * sizeof(bool)) == 0);
 
            /* Now, insert a Sort node if subplan isn't sufficiently ordered */
            if (!pathkeys_contained_in(pathkeys, subpath->pathkeys))
            {
                Sort       *sort = make_sort(subplan, numsortkeys,
                                             sortColIdx, sortOperators,
                                             collations, nullsFirst);
 
                label_sort_with_costsize(root, sort, best_path->limit_tuples);
                subplan = (Plan *) sort;
            }
        }
 
        /* If needed, check to see if subplan can be executed asynchronously */
        if (consider_async && mark_async_capable_plan(subplan, subpath))
        {
            Assert(subplan->async_capable);
            ++nasyncplans;
        }
 
        subplans = lappend(subplans, subplan);
    }
 
    /*
     * If any quals exist, they may be useful to perform further partition
     * pruning during execution.  Gather information needed by the executor to
     * do partition pruning.
     */
    if (enable_partition_pruning)
    {
        List       *prunequal;
 
        prunequal = extract_actual_clauses(rel->baserestrictinfo, false);
 
        if (best_path->path.param_info)
        {
            List       *prmquals = best_path->path.param_info->ppi_clauses;
 
            prmquals = extract_actual_clauses(prmquals, false);
            prmquals = (List *) replace_nestloop_params(root,
                                                        (Node *) prmquals);
 
            prunequal = list_concat(prunequal, prmquals);
        }
 
        if (prunequal != NIL)
            partpruneinfo =
                make_partition_pruneinfo(root, rel,
                                         best_path->subpaths,
                                         prunequal);
    }
 
    plan->appendplans = subplans;
    plan->nasyncplans = nasyncplans;
    plan->first_partial_plan = best_path->first_partial_path;
    plan->part_prune_info = partpruneinfo;
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    /*
     * If prepare_sort_from_pathkeys added sort columns, but we were told to
     * produce either the exact tlist or a narrow tlist, we should get rid of
     * the sort columns again.  We must inject a projection node to do so.
     */
    if (tlist_was_changed && (flags & (CP_EXACT_TLIST | CP_SMALL_TLIST)))
    {
        tlist = list_copy_head(plan->plan.targetlist, orig_tlist_length);
        return inject_projection_plan((Plan *) plan, tlist,
                                      plan->plan.parallel_safe);
    }
    else
        return (Plan *) plan;
}

References Assert(), Plan::async_capable, RelOptInfo::baserestrictinfo, build_path_tlist(), copy_generic_path_info(), CP_EXACT_TLIST, CP_SMALL_TLIST, create_plan_recurse(), elog(), enable_async_append, enable_partition_pruning, ERROR, extract_actual_clauses(), AppendPath::first_partial_path, inject_projection_plan(), label_sort_with_costsize(), lappend(), lfirst, AppendPath::limit_tuples, list_concat(), list_copy_head(), list_length(), list_make1, make_partition_pruneinfo(), make_result(), make_sort(), makeBoolConst(), makeNode, mark_async_capable_plan(), NIL, Path::parallel_safe, AppendPath::path, Path::pathkeys, pathkeys_contained_in(), plan, prepare_sort_from_pathkeys(), RelOptInfo::relids, replace_nestloop_params(), sort(), subpath(), and AppendPath::subpaths.

Referenced by create_plan_recurse().

create_bitmap_scan_plan()

static BitmapHeapScan * create_bitmap_scan_plan ( PlannerInfo *  root, BitmapHeapPath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3198 of file createplan.c.

{
    Index       baserelid = best_path->path.parent->relid;
    Plan       *bitmapqualplan;
    List       *bitmapqualorig;
    List       *indexquals;
    List       *indexECs;
    List       *qpqual;
    ListCell   *l;
    BitmapHeapScan *scan_plan;
 
    /* it should be a base rel... */
    Assert(baserelid > 0);
    Assert(best_path->path.parent->rtekind == RTE_RELATION);
 
    /* Process the bitmapqual tree into a Plan tree and qual lists */
    bitmapqualplan = create_bitmap_subplan(root, best_path->bitmapqual,
                                           &bitmapqualorig, &indexquals,
                                           &indexECs);
 
    if (best_path->path.parallel_aware)
        bitmap_subplan_mark_shared(bitmapqualplan);
 
    /*
     * The qpqual list must contain all restrictions not automatically handled
     * by the index, other than pseudoconstant clauses which will be handled
     * by a separate gating plan node.  All the predicates in the indexquals
     * will be checked (either by the index itself, or by
     * nodeBitmapHeapscan.c), but if there are any "special" operators
     * involved then they must be added to qpqual.  The upshot is that qpqual
     * must contain scan_clauses minus whatever appears in indexquals.
     *
     * This loop is similar to the comparable code in create_indexscan_plan(),
     * but with some differences because it has to compare the scan clauses to
     * stripped (no RestrictInfos) indexquals.  See comments there for more
     * info.
     *
     * In normal cases simple equal() checks will be enough to spot duplicate
     * clauses, so we try that first.  We next see if the scan clause is
     * redundant with any top-level indexqual by virtue of being generated
     * from the same EC.  After that, try predicate_implied_by().
     *
     * Unlike create_indexscan_plan(), the predicate_implied_by() test here is
     * useful for getting rid of qpquals that are implied by index predicates,
     * because the predicate conditions are included in the "indexquals"
     * returned by create_bitmap_subplan().  Bitmap scans have to do it that
     * way because predicate conditions need to be rechecked if the scan
     * becomes lossy, so they have to be included in bitmapqualorig.
     */
    qpqual = NIL;
    foreach(l, scan_clauses)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
        Node       *clause = (Node *) rinfo->clause;
 
        if (rinfo->pseudoconstant)
            continue;           /* we may drop pseudoconstants here */
        if (list_member(indexquals, clause))
            continue;           /* simple duplicate */
        if (rinfo->parent_ec && list_member_ptr(indexECs, rinfo->parent_ec))
            continue;           /* derived from same EquivalenceClass */
        if (!contain_mutable_functions(clause) &&
            predicate_implied_by(list_make1(clause), indexquals, false))
            continue;           /* provably implied by indexquals */
        qpqual = lappend(qpqual, rinfo);
    }
 
    /* Sort clauses into best execution order */
    qpqual = order_qual_clauses(root, qpqual);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    qpqual = extract_actual_clauses(qpqual, false);
 
    /*
     * When dealing with special operators, we will at this point have
     * duplicate clauses in qpqual and bitmapqualorig.  We may as well drop
     * 'em from bitmapqualorig, since there's no point in making the tests
     * twice.
     */
    bitmapqualorig = list_difference_ptr(bitmapqualorig, qpqual);
 
    /*
     * We have to replace any outer-relation variables with nestloop params in
     * the qpqual and bitmapqualorig expressions.  (This was already done for
     * expressions attached to plan nodes in the bitmapqualplan tree.)
     */
    if (best_path->path.param_info)
    {
        qpqual = (List *)
            replace_nestloop_params(root, (Node *) qpqual);
        bitmapqualorig = (List *)
            replace_nestloop_params(root, (Node *) bitmapqualorig);
    }
 
    /* Finally ready to build the plan node */
    scan_plan = make_bitmap_heapscan(tlist,
                                     qpqual,
                                     bitmapqualplan,
                                     bitmapqualorig,
                                     baserelid);
 
    copy_generic_path_info(&scan_plan->scan.plan, &best_path->path);
 
    return scan_plan;
}

References Assert(), bitmap_subplan_mark_shared(), BitmapHeapPath::bitmapqual, RestrictInfo::clause, contain_mutable_functions(), copy_generic_path_info(), create_bitmap_subplan(), extract_actual_clauses(), if(), lappend(), lfirst_node, list_difference_ptr(), list_make1, list_member(), list_member_ptr(), make_bitmap_heapscan(), NIL, order_qual_clauses(), Path::parallel_aware, BitmapHeapPath::path, predicate_implied_by(), replace_nestloop_params(), RTE_RELATION, and BitmapHeapScan::scan.

Referenced by create_scan_plan().

create_bitmap_subplan()

static Plan * create_bitmap_subplan ( PlannerInfo *  root, Path *  bitmapqual, List **  qual, List **  indexqual, List **  indexECs  )

static

Definition at line 3328 of file createplan.c.

{
    Plan       *plan;
 
    if (IsA(bitmapqual, BitmapAndPath))
    {
        BitmapAndPath *apath = (BitmapAndPath *) bitmapqual;
        List       *subplans = NIL;
        List       *subquals = NIL;
        List       *subindexquals = NIL;
        List       *subindexECs = NIL;
        ListCell   *l;
 
        /*
         * There may well be redundant quals among the subplans, since a
         * top-level WHERE qual might have gotten used to form several
         * different index quals.  We don't try exceedingly hard to eliminate
         * redundancies, but we do eliminate obvious duplicates by using
         * list_concat_unique.
         */
        foreach(l, apath->bitmapquals)
        {
            Plan       *subplan;
            List       *subqual;
            List       *subindexqual;
            List       *subindexEC;
 
            subplan = create_bitmap_subplan(root, (Path *) lfirst(l),
                                            &subqual, &subindexqual,
                                            &subindexEC);
            subplans = lappend(subplans, subplan);
            subquals = list_concat_unique(subquals, subqual);
            subindexquals = list_concat_unique(subindexquals, subindexqual);
            /* Duplicates in indexECs aren't worth getting rid of */
            subindexECs = list_concat(subindexECs, subindexEC);
        }
        plan = (Plan *) make_bitmap_and(subplans);
        plan->startup_cost = apath->path.startup_cost;
        plan->total_cost = apath->path.total_cost;
        plan->plan_rows =
            clamp_row_est(apath->bitmapselectivity * apath->path.parent->tuples);
        plan->plan_width = 0;   /* meaningless */
        plan->parallel_aware = false;
        plan->parallel_safe = apath->path.parallel_safe;
        *qual = subquals;
        *indexqual = subindexquals;
        *indexECs = subindexECs;
    }
    else if (IsA(bitmapqual, BitmapOrPath))
    {
        BitmapOrPath *opath = (BitmapOrPath *) bitmapqual;
        List       *subplans = NIL;
        List       *subquals = NIL;
        List       *subindexquals = NIL;
        bool        const_true_subqual = false;
        bool        const_true_subindexqual = false;
        ListCell   *l;
 
        /*
         * Here, we only detect qual-free subplans.  A qual-free subplan would
         * cause us to generate "... OR true ..."  which we may as well reduce
         * to just "true".  We do not try to eliminate redundant subclauses
         * because (a) it's not as likely as in the AND case, and (b) we might
         * well be working with hundreds or even thousands of OR conditions,
         * perhaps from a long IN list.  The performance of list_append_unique
         * would be unacceptable.
         */
        foreach(l, opath->bitmapquals)
        {
            Plan       *subplan;
            List       *subqual;
            List       *subindexqual;
            List       *subindexEC;
 
            subplan = create_bitmap_subplan(root, (Path *) lfirst(l),
                                            &subqual, &subindexqual,
                                            &subindexEC);
            subplans = lappend(subplans, subplan);
            if (subqual == NIL)
                const_true_subqual = true;
            else if (!const_true_subqual)
                subquals = lappend(subquals,
                                   make_ands_explicit(subqual));
            if (subindexqual == NIL)
                const_true_subindexqual = true;
            else if (!const_true_subindexqual)
                subindexquals = lappend(subindexquals,
                                        make_ands_explicit(subindexqual));
        }
 
        /*
         * In the presence of ScalarArrayOpExpr quals, we might have built
         * BitmapOrPaths with just one subpath; don't add an OR step.
         */
        if (list_length(subplans) == 1)
        {
            plan = (Plan *) linitial(subplans);
        }
        else
        {
            plan = (Plan *) make_bitmap_or(subplans);
            plan->startup_cost = opath->path.startup_cost;
            plan->total_cost = opath->path.total_cost;
            plan->plan_rows =
                clamp_row_est(opath->bitmapselectivity * opath->path.parent->tuples);
            plan->plan_width = 0;   /* meaningless */
            plan->parallel_aware = false;
            plan->parallel_safe = opath->path.parallel_safe;
        }
 
        /*
         * If there were constant-TRUE subquals, the OR reduces to constant
         * TRUE.  Also, avoid generating one-element ORs, which could happen
         * due to redundancy elimination or ScalarArrayOpExpr quals.
         */
        if (const_true_subqual)
            *qual = NIL;
        else if (list_length(subquals) <= 1)
            *qual = subquals;
        else
            *qual = list_make1(make_orclause(subquals));
        if (const_true_subindexqual)
            *indexqual = NIL;
        else if (list_length(subindexquals) <= 1)
            *indexqual = subindexquals;
        else
            *indexqual = list_make1(make_orclause(subindexquals));
        *indexECs = NIL;
    }
    else if (IsA(bitmapqual, IndexPath))
    {
        IndexPath  *ipath = (IndexPath *) bitmapqual;
        IndexScan  *iscan;
        List       *subquals;
        List       *subindexquals;
        List       *subindexECs;
        ListCell   *l;
 
        /* Use the regular indexscan plan build machinery... */
        iscan = castNode(IndexScan,
                         create_indexscan_plan(root, ipath,
                                               NIL, NIL, false));
        /* then convert to a bitmap indexscan */
        plan = (Plan *) make_bitmap_indexscan(iscan->scan.scanrelid,
                                              iscan->indexid,
                                              iscan->indexqual,
                                              iscan->indexqualorig);
        /* and set its cost/width fields appropriately */
        plan->startup_cost = 0.0;
        plan->total_cost = ipath->indextotalcost;
        plan->plan_rows =
            clamp_row_est(ipath->indexselectivity * ipath->path.parent->tuples);
        plan->plan_width = 0;   /* meaningless */
        plan->parallel_aware = false;
        plan->parallel_safe = ipath->path.parallel_safe;
        /* Extract original index clauses, actual index quals, relevant ECs */
        subquals = NIL;
        subindexquals = NIL;
        subindexECs = NIL;
        foreach(l, ipath->indexclauses)
        {
            IndexClause *iclause = (IndexClause *) lfirst(l);
            RestrictInfo *rinfo = iclause->rinfo;
 
            Assert(!rinfo->pseudoconstant);
            subquals = lappend(subquals, rinfo->clause);
            subindexquals = list_concat(subindexquals,
                                        get_actual_clauses(iclause->indexquals));
            if (rinfo->parent_ec)
                subindexECs = lappend(subindexECs, rinfo->parent_ec);
        }
        /* We can add any index predicate conditions, too */
        foreach(l, ipath->indexinfo->indpred)
        {
            Expr       *pred = (Expr *) lfirst(l);
 
            /*
             * We know that the index predicate must have been implied by the
             * query condition as a whole, but it may or may not be implied by
             * the conditions that got pushed into the bitmapqual.  Avoid
             * generating redundant conditions.
             */
            if (!predicate_implied_by(list_make1(pred), subquals, false))
            {
                subquals = lappend(subquals, pred);
                subindexquals = lappend(subindexquals, pred);
            }
        }
        *qual = subquals;
        *indexqual = subindexquals;
        *indexECs = subindexECs;
    }
    else
    {
        elog(ERROR, "unrecognized node type: %d", nodeTag(bitmapqual));
        plan = NULL;            /* keep compiler quiet */
    }
 
    return plan;
}

References Assert(), BitmapAndPath::bitmapquals, BitmapOrPath::bitmapquals, BitmapAndPath::bitmapselectivity, BitmapOrPath::bitmapselectivity, castNode, clamp_row_est(), RestrictInfo::clause, create_indexscan_plan(), elog(), ERROR, get_actual_clauses(), IndexPath::indexclauses, IndexScan::indexid, IndexPath::indexinfo, IndexScan::indexqual, IndexScan::indexqualorig, IndexClause::indexquals, IndexPath::indexselectivity, IndexPath::indextotalcost, IndexOptInfo::indpred, IsA, lappend(), lfirst, linitial, list_concat(), list_concat_unique(), list_length(), list_make1, make_ands_explicit(), make_bitmap_and(), make_bitmap_indexscan(), make_bitmap_or(), make_orclause(), NIL, nodeTag, Path::parallel_safe, IndexPath::path, BitmapAndPath::path, BitmapOrPath::path, plan, predicate_implied_by(), IndexClause::rinfo, IndexScan::scan, Scan::scanrelid, Path::startup_cost, and Path::total_cost.

Referenced by create_bitmap_scan_plan().

create_ctescan_plan()

static CteScan * create_ctescan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3878 of file createplan.c.

{
    CteScan    *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    SubPlan    *ctesplan = NULL;
    int         plan_id;
    int         cte_param_id;
    PlannerInfo *cteroot;
    Index       levelsup;
    int         ndx;
    ListCell   *lc;
 
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_CTE);
    Assert(!rte->self_reference);
 
    /*
     * Find the referenced CTE, and locate the SubPlan previously made for it.
     */
    levelsup = rte->ctelevelsup;
    cteroot = root;
    while (levelsup-- > 0)
    {
        cteroot = cteroot->parent_root;
        if (!cteroot)           /* shouldn't happen */
            elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    }
 
    /*
     * Note: cte_plan_ids can be shorter than cteList, if we are still working
     * on planning the CTEs (ie, this is a side-reference from another CTE).
     * So we mustn't use forboth here.
     */
    ndx = 0;
    foreach(lc, cteroot->parse->cteList)
    {
        CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 
        if (strcmp(cte->ctename, rte->ctename) == 0)
            break;
        ndx++;
    }
    if (lc == NULL)             /* shouldn't happen */
        elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
    if (ndx >= list_length(cteroot->cte_plan_ids))
        elog(ERROR, "could not find plan for CTE \"%s\"", rte->ctename);
    plan_id = list_nth_int(cteroot->cte_plan_ids, ndx);
    if (plan_id <= 0)
        elog(ERROR, "no plan was made for CTE \"%s\"", rte->ctename);
    foreach(lc, cteroot->init_plans)
    {
        ctesplan = (SubPlan *) lfirst(lc);
        if (ctesplan->plan_id == plan_id)
            break;
    }
    if (lc == NULL)             /* shouldn't happen */
        elog(ERROR, "could not find plan for CTE \"%s\"", rte->ctename);
 
    /*
     * We need the CTE param ID, which is the sole member of the SubPlan's
     * setParam list.
     */
    cte_param_id = linitial_int(ctesplan->setParam);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_ctescan(tlist, scan_clauses, scan_relid,
                             plan_id, cte_param_id);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), PlannerInfo::cte_plan_ids, RangeTblEntry::ctelevelsup, Query::cteList, RangeTblEntry::ctename, CommonTableExpr::ctename, elog(), ERROR, extract_actual_clauses(), PlannerInfo::init_plans, lfirst, linitial_int, list_length(), list_nth_int(), make_ctescan(), order_qual_clauses(), PlannerInfo::parse, SubPlan::plan_id, planner_rt_fetch, replace_nestloop_params(), RTE_CTE, RangeTblEntry::rtekind, CteScan::scan, RangeTblEntry::self_reference, and SubPlan::setParam.

Referenced by create_scan_plan().

create_customscan_plan()

static CustomScan * create_customscan_plan ( PlannerInfo *  root, CustomPath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 4264 of file createplan.c.

{
    CustomScan *cplan;
    RelOptInfo *rel = best_path->path.parent;
    List       *custom_plans = NIL;
    ListCell   *lc;
 
    /* Recursively transform child paths. */
    foreach(lc, best_path->custom_paths)
    {
        Plan       *plan = create_plan_recurse(root, (Path *) lfirst(lc),
                                               CP_EXACT_TLIST);
 
        custom_plans = lappend(custom_plans, plan);
    }
 
    /*
     * Sort clauses into the best execution order, although custom-scan
     * provider can reorder them again.
     */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /*
     * Invoke custom plan provider to create the Plan node represented by the
     * CustomPath.
     */
    cplan = castNode(CustomScan,
                     best_path->methods->PlanCustomPath(root,
                                                        rel,
                                                        best_path,
                                                        tlist,
                                                        scan_clauses,
                                                        custom_plans));
 
    /*
     * Copy cost data from Path to Plan; no need to make custom-plan providers
     * do this
     */
    copy_generic_path_info(&cplan->scan.plan, &best_path->path);
 
    /* Likewise, copy the relids that are represented by this custom scan */
    cplan->custom_relids = best_path->path.parent->relids;
 
    /*
     * Replace any outer-relation variables with nestloop params in the qual
     * and custom_exprs expressions.  We do this last so that the custom-plan
     * provider doesn't have to be involved.  (Note that parts of custom_exprs
     * could have come from join clauses, so doing this beforehand on the
     * scan_clauses wouldn't work.)  We assume custom_scan_tlist contains no
     * such variables.
     */
    if (best_path->path.param_info)
    {
        cplan->scan.plan.qual = (List *)
            replace_nestloop_params(root, (Node *) cplan->scan.plan.qual);
        cplan->custom_exprs = (List *)
            replace_nestloop_params(root, (Node *) cplan->custom_exprs);
    }
 
    return cplan;
}

References castNode, copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), CustomScan::custom_exprs, CustomPath::custom_paths, CustomScan::custom_relids, lappend(), lfirst, CustomPath::methods, NIL, order_qual_clauses(), CustomPath::path, plan, CustomPathMethods::PlanCustomPath, replace_nestloop_params(), and CustomScan::scan.

Referenced by create_scan_plan().

create_foreignscan_plan()

static ForeignScan * create_foreignscan_plan ( PlannerInfo *  root, ForeignPath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 4109 of file createplan.c.

{
    ForeignScan *scan_plan;
    RelOptInfo *rel = best_path->path.parent;
    Index       scan_relid = rel->relid;
    Oid         rel_oid = InvalidOid;
    Plan       *outer_plan = NULL;
 
    Assert(rel->fdwroutine != NULL);
 
    /* transform the child path if any */
    if (best_path->fdw_outerpath)
        outer_plan = create_plan_recurse(root, best_path->fdw_outerpath,
                                         CP_EXACT_TLIST);
 
    /*
     * If we're scanning a base relation, fetch its OID.  (Irrelevant if
     * scanning a join relation.)
     */
    if (scan_relid > 0)
    {
        RangeTblEntry *rte;
 
        Assert(rel->rtekind == RTE_RELATION);
        rte = planner_rt_fetch(scan_relid, root);
        Assert(rte->rtekind == RTE_RELATION);
        rel_oid = rte->relid;
    }
 
    /*
     * Sort clauses into best execution order.  We do this first since the FDW
     * might have more info than we do and wish to adjust the ordering.
     */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /*
     * Let the FDW perform its processing on the restriction clauses and
     * generate the plan node.  Note that the FDW might remove restriction
     * clauses that it intends to execute remotely, or even add more (if it
     * has selected some join clauses for remote use but also wants them
     * rechecked locally).
     */
    scan_plan = rel->fdwroutine->GetForeignPlan(root, rel, rel_oid,
                                                best_path,
                                                tlist, scan_clauses,
                                                outer_plan);
 
    /* Copy cost data from Path to Plan; no need to make FDW do this */
    copy_generic_path_info(&scan_plan->scan.plan, &best_path->path);
 
    /* Copy user OID to access as; likewise no need to make FDW do this */
    scan_plan->checkAsUser = rel->userid;
 
    /* Copy foreign server OID; likewise, no need to make FDW do this */
    scan_plan->fs_server = rel->serverid;
 
    /*
     * Likewise, copy the relids that are represented by this foreign scan. An
     * upper rel doesn't have relids set, but it covers all the relations
     * participating in the underlying scan/join, so use root->all_query_rels.
     */
    if (rel->reloptkind == RELOPT_UPPER_REL)
        scan_plan->fs_relids = root->all_query_rels;
    else
        scan_plan->fs_relids = best_path->path.parent->relids;
 
    /*
     * Join relid sets include relevant outer joins, but FDWs may need to know
     * which are the included base rels.  That's a bit tedious to get without
     * access to the plan-time data structures, so compute it here.
     */
    scan_plan->fs_base_relids = bms_difference(scan_plan->fs_relids,
                                               root->outer_join_rels);
 
    /*
     * If this is a foreign join, and to make it valid to push down we had to
     * assume that the current user is the same as some user explicitly named
     * in the query, mark the finished plan as depending on the current user.
     */
    if (rel->useridiscurrent)
        root->glob->dependsOnRole = true;
 
    /*
     * Replace any outer-relation variables with nestloop params in the qual,
     * fdw_exprs and fdw_recheck_quals expressions.  We do this last so that
     * the FDW doesn't have to be involved.  (Note that parts of fdw_exprs or
     * fdw_recheck_quals could have come from join clauses, so doing this
     * beforehand on the scan_clauses wouldn't work.)  We assume
     * fdw_scan_tlist contains no such variables.
     */
    if (best_path->path.param_info)
    {
        scan_plan->scan.plan.qual = (List *)
            replace_nestloop_params(root, (Node *) scan_plan->scan.plan.qual);
        scan_plan->fdw_exprs = (List *)
            replace_nestloop_params(root, (Node *) scan_plan->fdw_exprs);
        scan_plan->fdw_recheck_quals = (List *)
            replace_nestloop_params(root,
                                    (Node *) scan_plan->fdw_recheck_quals);
    }
 
    /*
     * If rel is a base relation, detect whether any system columns are
     * requested from the rel.  (If rel is a join relation, rel->relid will be
     * 0, but there can be no Var with relid 0 in the rel's targetlist or the
     * restriction clauses, so we skip this in that case.  Note that any such
     * columns in base relations that were joined are assumed to be contained
     * in fdw_scan_tlist.)  This is a bit of a kluge and might go away
     * someday, so we intentionally leave it out of the API presented to FDWs.
     */
    scan_plan->fsSystemCol = false;
    if (scan_relid > 0)
    {
        Bitmapset  *attrs_used = NULL;
        ListCell   *lc;
        int         i;
 
        /*
         * First, examine all the attributes needed for joins or final output.
         * Note: we must look at rel's targetlist, not the attr_needed data,
         * because attr_needed isn't computed for inheritance child rels.
         */
        pull_varattnos((Node *) rel->reltarget->exprs, scan_relid, &attrs_used);
 
        /* Add all the attributes used by restriction clauses. */
        foreach(lc, rel->baserestrictinfo)
        {
            RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
            pull_varattnos((Node *) rinfo->clause, scan_relid, &attrs_used);
        }
 
        /* Now, are any system columns requested from rel? */
        for (i = FirstLowInvalidHeapAttributeNumber + 1; i < 0; i++)
        {
            if (bms_is_member(i - FirstLowInvalidHeapAttributeNumber, attrs_used))
            {
                scan_plan->fsSystemCol = true;
                break;
            }
        }
 
        bms_free(attrs_used);
    }
 
    return scan_plan;
}

References PlannerInfo::all_query_rels, Assert(), RelOptInfo::baserestrictinfo, bms_difference(), bms_free(), bms_is_member(), ForeignScan::checkAsUser, RestrictInfo::clause, copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), PlannerGlobal::dependsOnRole, PathTarget::exprs, ForeignScan::fdw_exprs, ForeignPath::fdw_outerpath, ForeignScan::fdw_recheck_quals, FirstLowInvalidHeapAttributeNumber, ForeignScan::fs_base_relids, ForeignScan::fs_relids, ForeignScan::fs_server, ForeignScan::fsSystemCol, PlannerInfo::glob, i, InvalidOid, lfirst, order_qual_clauses(), PlannerInfo::outer_join_rels, ForeignPath::path, planner_rt_fetch, pull_varattnos(), RangeTblEntry::relid, RelOptInfo::relid, RELOPT_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, replace_nestloop_params(), RTE_RELATION, RangeTblEntry::rtekind, RelOptInfo::rtekind, ForeignScan::scan, RelOptInfo::serverid, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by create_scan_plan().

create_functionscan_plan()

static FunctionScan * create_functionscan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3748 of file createplan.c.

{
    FunctionScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    List       *functions;
 
    /* it should be a function base rel... */
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_FUNCTION);
    functions = rte->functions;
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
        /* The function expressions could contain nestloop params, too */
        functions = (List *) replace_nestloop_params(root, (Node *) functions);
    }
 
    scan_plan = make_functionscan(tlist, scan_clauses, scan_relid,
                                  functions, rte->funcordinality);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), extract_actual_clauses(), RangeTblEntry::funcordinality, functions, RangeTblEntry::functions, make_functionscan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), RTE_FUNCTION, RangeTblEntry::rtekind, and FunctionScan::scan.

Referenced by create_scan_plan().

create_gather_merge_plan()

static GatherMerge * create_gather_merge_plan ( PlannerInfo *  root, GatherMergePath *  best_path  )

static

Definition at line 1955 of file createplan.c.

{
    GatherMerge *gm_plan;
    Plan       *subplan;
    List       *pathkeys = best_path->path.pathkeys;
    List       *tlist = build_path_tlist(root, &best_path->path);
 
    /* As with Gather, project away columns in the workers. */
    subplan = create_plan_recurse(root, best_path->subpath, CP_EXACT_TLIST);
 
    /* Create a shell for a GatherMerge plan. */
    gm_plan = makeNode(GatherMerge);
    gm_plan->plan.targetlist = tlist;
    gm_plan->num_workers = best_path->num_workers;
    copy_generic_path_info(&gm_plan->plan, &best_path->path);
 
    /* Assign the rescan Param. */
    gm_plan->rescan_param = assign_special_exec_param(root);
 
    /* Gather Merge is pointless with no pathkeys; use Gather instead. */
    Assert(pathkeys != NIL);
 
    /* Compute sort column info, and adjust subplan's tlist as needed */
    subplan = prepare_sort_from_pathkeys(subplan, pathkeys,
                                         best_path->subpath->parent->relids,
                                         gm_plan->sortColIdx,
                                         false,
                                         &gm_plan->numCols,
                                         &gm_plan->sortColIdx,
                                         &gm_plan->sortOperators,
                                         &gm_plan->collations,
                                         &gm_plan->nullsFirst);
 
 
    /*
     * All gather merge paths should have already guaranteed the necessary
     * sort order either by adding an explicit sort node or by using presorted
     * input. We can't simply add a sort here on additional pathkeys, because
     * we can't guarantee the sort would be safe. For example, expressions may
     * be volatile or otherwise parallel unsafe.
     */
    if (!pathkeys_contained_in(pathkeys, best_path->subpath->pathkeys))
        elog(ERROR, "gather merge input not sufficiently sorted");
 
    /* Now insert the subplan under GatherMerge. */
    gm_plan->plan.lefttree = subplan;
 
    /* use parallel mode for parallel plans. */
    root->glob->parallelModeNeeded = true;
 
    return gm_plan;
}

References Assert(), assign_special_exec_param(), build_path_tlist(), copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), elog(), ERROR, PlannerInfo::glob, Plan::lefttree, makeNode, NIL, GatherMergePath::num_workers, GatherMerge::num_workers, GatherMerge::numCols, PlannerGlobal::parallelModeNeeded, GatherMergePath::path, Path::pathkeys, pathkeys_contained_in(), GatherMerge::plan, prepare_sort_from_pathkeys(), GatherMerge::rescan_param, GatherMergePath::subpath, and Plan::targetlist.

Referenced by create_plan_recurse().

create_gather_plan()

static Gather * create_gather_plan ( PlannerInfo *  root, GatherPath *  best_path  )

static

Definition at line 1917 of file createplan.c.

{
    Gather     *gather_plan;
    Plan       *subplan;
    List       *tlist;
 
    /*
     * Push projection down to the child node.  That way, the projection work
     * is parallelized, and there can be no system columns in the result (they
     * can't travel through a tuple queue because it uses MinimalTuple
     * representation).
     */
    subplan = create_plan_recurse(root, best_path->subpath, CP_EXACT_TLIST);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    gather_plan = make_gather(tlist,
                              NIL,
                              best_path->num_workers,
                              assign_special_exec_param(root),
                              best_path->single_copy,
                              subplan);
 
    copy_generic_path_info(&gather_plan->plan, &best_path->path);
 
    /* use parallel mode for parallel plans. */
    root->glob->parallelModeNeeded = true;
 
    return gather_plan;
}

References assign_special_exec_param(), build_path_tlist(), copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), PlannerInfo::glob, make_gather(), NIL, GatherPath::num_workers, PlannerGlobal::parallelModeNeeded, GatherPath::path, Gather::plan, GatherPath::single_copy, and GatherPath::subpath.

Referenced by create_plan_recurse().

create_gating_plan()

static Plan * create_gating_plan ( PlannerInfo *  root, Path *  path, Plan *  plan, List *  gating_quals  )

static

Definition at line 1020 of file createplan.c.

{
    Plan       *gplan;
    Plan       *splan;
 
    Assert(gating_quals);
 
    /*
     * We might have a trivial Result plan already.  Stacking one Result atop
     * another is silly, so if that applies, just discard the input plan.
     * (We're assuming its targetlist is uninteresting; it should be either
     * the same as the result of build_path_tlist, or a simplified version.)
     */
    splan = plan;
    if (IsA(plan, Result))
    {
        Result     *rplan = (Result *) plan;
 
        if (rplan->plan.lefttree == NULL &&
            rplan->resconstantqual == NULL)
            splan = NULL;
    }
 
    /*
     * Since we need a Result node anyway, always return the path's requested
     * tlist; that's never a wrong choice, even if the parent node didn't ask
     * for CP_EXACT_TLIST.
     */
    gplan = (Plan *) make_result(build_path_tlist(root, path),
                                 (Node *) gating_quals,
                                 splan);
 
    /*
     * Notice that we don't change cost or size estimates when doing gating.
     * The costs of qual eval were already included in the subplan's cost.
     * Leaving the size alone amounts to assuming that the gating qual will
     * succeed, which is the conservative estimate for planning upper queries.
     * We certainly don't want to assume the output size is zero (unless the
     * gating qual is actually constant FALSE, and that case is dealt with in
     * clausesel.c).  Interpolating between the two cases is silly, because it
     * doesn't reflect what will really happen at runtime, and besides which
     * in most cases we have only a very bad idea of the probability of the
     * gating qual being true.
     */
    copy_plan_costsize(gplan, plan);
 
    /* Gating quals could be unsafe, so better use the Path's safety flag */
    gplan->parallel_safe = path->parallel_safe;
 
    return gplan;
}

References Assert(), build_path_tlist(), copy_plan_costsize(), IsA, Plan::lefttree, make_result(), Path::parallel_safe, Plan::parallel_safe, Result::plan, plan, Result::resconstantqual, and splan.

Referenced by create_join_plan(), and create_scan_plan().

create_group_plan()

static Group * create_group_plan ( PlannerInfo *  root, GroupPath *  best_path  )

static

Definition at line 2239 of file createplan.c.

{
    Group      *plan;
    Plan       *subplan;
    List       *tlist;
    List       *quals;
 
    /*
     * Group can project, so no need to be terribly picky about child tlist,
     * but we do need grouping columns to be available
     */
    subplan = create_plan_recurse(root, best_path->subpath, CP_LABEL_TLIST);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    quals = order_qual_clauses(root, best_path->qual);
 
    plan = make_group(tlist,
                      quals,
                      list_length(best_path->groupClause),
                      extract_grouping_cols(best_path->groupClause,
                                            subplan->targetlist),
                      extract_grouping_ops(best_path->groupClause),
                      extract_grouping_collations(best_path->groupClause,
                                                  subplan->targetlist),
                      subplan);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References build_path_tlist(), copy_generic_path_info(), CP_LABEL_TLIST, create_plan_recurse(), extract_grouping_collations(), extract_grouping_cols(), extract_grouping_ops(), GroupPath::groupClause, list_length(), make_group(), order_qual_clauses(), GroupPath::path, plan, GroupPath::qual, GroupPath::subpath, and Plan::targetlist.

Referenced by create_plan_recurse().

create_group_result_plan()

static Result * create_group_result_plan ( PlannerInfo *  root, GroupResultPath *  best_path  )

static

Definition at line 1585 of file createplan.c.

{
    Result     *plan;
    List       *tlist;
    List       *quals;
 
    tlist = build_path_tlist(root, &best_path->path);
 
    /* best_path->quals is just bare clauses */
    quals = order_qual_clauses(root, best_path->quals);
 
    plan = make_result(tlist, (Node *) quals, NULL);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References build_path_tlist(), copy_generic_path_info(), make_result(), order_qual_clauses(), GroupResultPath::path, plan, and GroupResultPath::quals.

Referenced by create_plan_recurse().

create_groupingsets_plan()

static Plan * create_groupingsets_plan ( PlannerInfo *  root, GroupingSetsPath *  best_path  )

static

Definition at line 2390 of file createplan.c.

{
    Agg        *plan;
    Plan       *subplan;
    List       *rollups = best_path->rollups;
    AttrNumber *grouping_map;
    int         maxref;
    List       *chain;
    ListCell   *lc;
 
    /* Shouldn't get here without grouping sets */
    Assert(root->parse->groupingSets);
    Assert(rollups != NIL);
 
    /*
     * Agg can project, so no need to be terribly picky about child tlist, but
     * we do need grouping columns to be available
     */
    subplan = create_plan_recurse(root, best_path->subpath, CP_LABEL_TLIST);
 
    /*
     * Compute the mapping from tleSortGroupRef to column index in the child's
     * tlist.  First, identify max SortGroupRef in groupClause, for array
     * sizing.
     */
    maxref = 0;
    foreach(lc, root->processed_groupClause)
    {
        SortGroupClause *gc = (SortGroupClause *) lfirst(lc);
 
        if (gc->tleSortGroupRef > maxref)
            maxref = gc->tleSortGroupRef;
    }
 
    grouping_map = (AttrNumber *) palloc0((maxref + 1) * sizeof(AttrNumber));
 
    /* Now look up the column numbers in the child's tlist */
    foreach(lc, root->processed_groupClause)
    {
        SortGroupClause *gc = (SortGroupClause *) lfirst(lc);
        TargetEntry *tle = get_sortgroupclause_tle(gc, subplan->targetlist);
 
        grouping_map[gc->tleSortGroupRef] = tle->resno;
    }
 
    /*
     * During setrefs.c, we'll need the grouping_map to fix up the cols lists
     * in GroupingFunc nodes.  Save it for setrefs.c to use.
     */
    Assert(root->grouping_map == NULL);
    root->grouping_map = grouping_map;
 
    /*
     * Generate the side nodes that describe the other sort and group
     * operations besides the top one.  Note that we don't worry about putting
     * accurate cost estimates in the side nodes; only the topmost Agg node's
     * costs will be shown by EXPLAIN.
     */
    chain = NIL;
    if (list_length(rollups) > 1)
    {
        bool        is_first_sort = ((RollupData *) linitial(rollups))->is_hashed;
 
        for_each_from(lc, rollups, 1)
        {
            RollupData *rollup = lfirst(lc);
            AttrNumber *new_grpColIdx;
            Plan       *sort_plan = NULL;
            Plan       *agg_plan;
            AggStrategy strat;
 
            new_grpColIdx = remap_groupColIdx(root, rollup->groupClause);
 
            if (!rollup->is_hashed && !is_first_sort)
            {
                sort_plan = (Plan *)
                    make_sort_from_groupcols(rollup->groupClause,
                                             new_grpColIdx,
                                             subplan);
            }
 
            if (!rollup->is_hashed)
                is_first_sort = false;
 
            if (rollup->is_hashed)
                strat = AGG_HASHED;
            else if (linitial(rollup->gsets) == NIL)
                strat = AGG_PLAIN;
            else
                strat = AGG_SORTED;
 
            agg_plan = (Plan *) make_agg(NIL,
                                         NIL,
                                         strat,
                                         AGGSPLIT_SIMPLE,
                                         list_length((List *) linitial(rollup->gsets)),
                                         new_grpColIdx,
                                         extract_grouping_ops(rollup->groupClause),
                                         extract_grouping_collations(rollup->groupClause, subplan->targetlist),
                                         rollup->gsets,
                                         NIL,
                                         rollup->numGroups,
                                         best_path->transitionSpace,
                                         sort_plan);
 
            /*
             * Remove stuff we don't need to avoid bloating debug output.
             */
            if (sort_plan)
            {
                sort_plan->targetlist = NIL;
                sort_plan->lefttree = NULL;
            }
 
            chain = lappend(chain, agg_plan);
        }
    }
 
    /*
     * Now make the real Agg node
     */
    {
        RollupData *rollup = linitial(rollups);
        AttrNumber *top_grpColIdx;
        int         numGroupCols;
 
        top_grpColIdx = remap_groupColIdx(root, rollup->groupClause);
 
        numGroupCols = list_length((List *) linitial(rollup->gsets));
 
        plan = make_agg(build_path_tlist(root, &best_path->path),
                        best_path->qual,
                        best_path->aggstrategy,
                        AGGSPLIT_SIMPLE,
                        numGroupCols,
                        top_grpColIdx,
                        extract_grouping_ops(rollup->groupClause),
                        extract_grouping_collations(rollup->groupClause, subplan->targetlist),
                        rollup->gsets,
                        chain,
                        rollup->numGroups,
                        best_path->transitionSpace,
                        subplan);
 
        /* Copy cost data from Path to Plan */
        copy_generic_path_info(&plan->plan, &best_path->path);
    }
 
    return (Plan *) plan;
}

References AGG_HASHED, AGG_PLAIN, AGG_SORTED, AGGSPLIT_SIMPLE, GroupingSetsPath::aggstrategy, Assert(), build_path_tlist(), copy_generic_path_info(), CP_LABEL_TLIST, create_plan_recurse(), extract_grouping_collations(), extract_grouping_ops(), for_each_from, get_sortgroupclause_tle(), RollupData::groupClause, Query::groupingSets, RollupData::gsets, RollupData::is_hashed, lappend(), Plan::lefttree, lfirst, linitial, list_length(), make_agg(), make_sort_from_groupcols(), NIL, RollupData::numGroups, palloc0(), PlannerInfo::parse, GroupingSetsPath::path, plan, PlannerInfo::processed_groupClause, GroupingSetsPath::qual, remap_groupColIdx(), TargetEntry::resno, GroupingSetsPath::rollups, GroupingSetsPath::subpath, Plan::targetlist, SortGroupClause::tleSortGroupRef, and GroupingSetsPath::transitionSpace.

Referenced by create_plan_recurse().

create_hashjoin_plan()

static HashJoin * create_hashjoin_plan ( PlannerInfo *  root, HashPath *  best_path  )

static

Definition at line 4718 of file createplan.c.

{
    HashJoin   *join_plan;
    Hash       *hash_plan;
    Plan       *outer_plan;
    Plan       *inner_plan;
    List       *tlist = build_path_tlist(root, &best_path->jpath.path);
    List       *joinclauses;
    List       *otherclauses;
    List       *hashclauses;
    List       *hashoperators = NIL;
    List       *hashcollations = NIL;
    List       *inner_hashkeys = NIL;
    List       *outer_hashkeys = NIL;
    Oid         skewTable = InvalidOid;
    AttrNumber  skewColumn = InvalidAttrNumber;
    bool        skewInherit = false;
    ListCell   *lc;
 
    /*
     * HashJoin can project, so we don't have to demand exact tlists from the
     * inputs.  However, it's best to request a small tlist from the inner
     * side, so that we aren't storing more data than necessary.  Likewise, if
     * we anticipate batching, request a small tlist from the outer side so
     * that we don't put extra data in the outer batch files.
     */
    outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath,
                                     (best_path->num_batches > 1) ? CP_SMALL_TLIST : 0);
 
    inner_plan = create_plan_recurse(root, best_path->jpath.innerjoinpath,
                                     CP_SMALL_TLIST);
 
    /* Sort join qual clauses into best execution order */
    joinclauses = order_qual_clauses(root, best_path->jpath.joinrestrictinfo);
    /* There's no point in sorting the hash clauses ... */
 
    /* Get the join qual clauses (in plain expression form) */
    /* Any pseudoconstant clauses are ignored here */
    if (IS_OUTER_JOIN(best_path->jpath.jointype))
    {
        extract_actual_join_clauses(joinclauses,
                                    best_path->jpath.path.parent->relids,
                                    &joinclauses, &otherclauses);
    }
    else
    {
        /* We can treat all clauses alike for an inner join */
        joinclauses = extract_actual_clauses(joinclauses, false);
        otherclauses = NIL;
    }
 
    /*
     * Remove the hashclauses from the list of join qual clauses, leaving the
     * list of quals that must be checked as qpquals.
     */
    hashclauses = get_actual_clauses(best_path->path_hashclauses);
    joinclauses = list_difference(joinclauses, hashclauses);
 
    /*
     * Replace any outer-relation variables with nestloop params.  There
     * should not be any in the hashclauses.
     */
    if (best_path->jpath.path.param_info)
    {
        joinclauses = (List *)
            replace_nestloop_params(root, (Node *) joinclauses);
        otherclauses = (List *)
            replace_nestloop_params(root, (Node *) otherclauses);
    }
 
    /*
     * Rearrange hashclauses, if needed, so that the outer variable is always
     * on the left.
     */
    hashclauses = get_switched_clauses(best_path->path_hashclauses,
                                       best_path->jpath.outerjoinpath->parent->relids);
 
    /*
     * If there is a single join clause and we can identify the outer variable
     * as a simple column reference, supply its identity for possible use in
     * skew optimization.  (Note: in principle we could do skew optimization
     * with multiple join clauses, but we'd have to be able to determine the
     * most common combinations of outer values, which we don't currently have
     * enough stats for.)
     */
    if (list_length(hashclauses) == 1)
    {
        OpExpr     *clause = (OpExpr *) linitial(hashclauses);
        Node       *node;
 
        Assert(is_opclause(clause));
        node = (Node *) linitial(clause->args);
        if (IsA(node, RelabelType))
            node = (Node *) ((RelabelType *) node)->arg;
        if (IsA(node, Var))
        {
            Var        *var = (Var *) node;
            RangeTblEntry *rte;
 
            rte = root->simple_rte_array[var->varno];
            if (rte->rtekind == RTE_RELATION)
            {
                skewTable = rte->relid;
                skewColumn = var->varattno;
                skewInherit = rte->inh;
            }
        }
    }
 
    /*
     * Collect hash related information. The hashed expressions are
     * deconstructed into outer/inner expressions, so they can be computed
     * separately (inner expressions are used to build the hashtable via Hash,
     * outer expressions to perform lookups of tuples from HashJoin's outer
     * plan in the hashtable). Also collect operator information necessary to
     * build the hashtable.
     */
    foreach(lc, hashclauses)
    {
        OpExpr     *hclause = lfirst_node(OpExpr, lc);
 
        hashoperators = lappend_oid(hashoperators, hclause->opno);
        hashcollations = lappend_oid(hashcollations, hclause->inputcollid);
        outer_hashkeys = lappend(outer_hashkeys, linitial(hclause->args));
        inner_hashkeys = lappend(inner_hashkeys, lsecond(hclause->args));
    }
 
    /*
     * Build the hash node and hash join node.
     */
    hash_plan = make_hash(inner_plan,
                          inner_hashkeys,
                          skewTable,
                          skewColumn,
                          skewInherit);
 
    /*
     * Set Hash node's startup & total costs equal to total cost of input
     * plan; this only affects EXPLAIN display not decisions.
     */
    copy_plan_costsize(&hash_plan->plan, inner_plan);
    hash_plan->plan.startup_cost = hash_plan->plan.total_cost;
 
    /*
     * If parallel-aware, the executor will also need an estimate of the total
     * number of rows expected from all participants so that it can size the
     * shared hash table.
     */
    if (best_path->jpath.path.parallel_aware)
    {
        hash_plan->plan.parallel_aware = true;
        hash_plan->rows_total = best_path->inner_rows_total;
    }
 
    join_plan = make_hashjoin(tlist,
                              joinclauses,
                              otherclauses,
                              hashclauses,
                              hashoperators,
                              hashcollations,
                              outer_hashkeys,
                              outer_plan,
                              (Plan *) hash_plan,
                              best_path->jpath.jointype,
                              best_path->jpath.inner_unique);
 
    copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
 
    return join_plan;
}

References OpExpr::args, Assert(), build_path_tlist(), copy_generic_path_info(), copy_plan_costsize(), CP_SMALL_TLIST, create_plan_recurse(), extract_actual_clauses(), extract_actual_join_clauses(), get_actual_clauses(), get_switched_clauses(), RangeTblEntry::inh, HashPath::inner_rows_total, JoinPath::inner_unique, JoinPath::innerjoinpath, InvalidAttrNumber, InvalidOid, is_opclause(), IS_OUTER_JOIN, IsA, HashJoin::join, JoinPath::joinrestrictinfo, JoinPath::jointype, HashPath::jpath, lappend(), lappend_oid(), lfirst_node, linitial, list_difference(), list_length(), lsecond, make_hash(), make_hashjoin(), NIL, HashPath::num_batches, OpExpr::opno, order_qual_clauses(), JoinPath::outerjoinpath, Plan::parallel_aware, HashPath::path_hashclauses, Hash::plan, RangeTblEntry::relid, replace_nestloop_params(), Hash::rows_total, RTE_RELATION, RangeTblEntry::rtekind, Plan::startup_cost, Plan::total_cost, Var::varattno, and Var::varno.

Referenced by create_join_plan().

create_incrementalsort_plan()

static IncrementalSort * create_incrementalsort_plan ( PlannerInfo *  root, IncrementalSortPath *  best_path, int  flags  )

static

Definition at line 2212 of file createplan.c.

{
    IncrementalSort *plan;
    Plan       *subplan;
 
    /* See comments in create_sort_plan() above */
    subplan = create_plan_recurse(root, best_path->spath.subpath,
                                  flags | CP_SMALL_TLIST);
    plan = make_incrementalsort_from_pathkeys(subplan,
                                              best_path->spath.path.pathkeys,
                                              IS_OTHER_REL(best_path->spath.subpath->parent) ?
                                              best_path->spath.path.parent->relids : NULL,
                                              best_path->nPresortedCols);
 
    copy_generic_path_info(&plan->sort.plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), CP_SMALL_TLIST, create_plan_recurse(), IS_OTHER_REL, make_incrementalsort_from_pathkeys(), IncrementalSortPath::nPresortedCols, SortPath::path, Path::pathkeys, plan, IncrementalSortPath::spath, and SortPath::subpath.

Referenced by create_plan_recurse().

create_indexscan_plan()

static Scan * create_indexscan_plan ( PlannerInfo *  root, IndexPath *  best_path, List *  tlist, List *  scan_clauses, bool  indexonly  )

static

Definition at line 3002 of file createplan.c.

{
    Scan       *scan_plan;
    List       *indexclauses = best_path->indexclauses;
    List       *indexorderbys = best_path->indexorderbys;
    Index       baserelid = best_path->path.parent->relid;
    IndexOptInfo *indexinfo = best_path->indexinfo;
    Oid         indexoid = indexinfo->indexoid;
    List       *qpqual;
    List       *stripped_indexquals;
    List       *fixed_indexquals;
    List       *fixed_indexorderbys;
    List       *indexorderbyops = NIL;
    ListCell   *l;
 
    /* it should be a base rel... */
    Assert(baserelid > 0);
    Assert(best_path->path.parent->rtekind == RTE_RELATION);
    /* check the scan direction is valid */
    Assert(best_path->indexscandir == ForwardScanDirection ||
           best_path->indexscandir == BackwardScanDirection);
 
    /*
     * Extract the index qual expressions (stripped of RestrictInfos) from the
     * IndexClauses list, and prepare a copy with index Vars substituted for
     * table Vars.  (This step also does replace_nestloop_params on the
     * fixed_indexquals.)
     */
    fix_indexqual_references(root, best_path,
                             &stripped_indexquals,
                             &fixed_indexquals);
 
    /*
     * Likewise fix up index attr references in the ORDER BY expressions.
     */
    fixed_indexorderbys = fix_indexorderby_references(root, best_path);
 
    /*
     * The qpqual list must contain all restrictions not automatically handled
     * by the index, other than pseudoconstant clauses which will be handled
     * by a separate gating plan node.  All the predicates in the indexquals
     * will be checked (either by the index itself, or by nodeIndexscan.c),
     * but if there are any "special" operators involved then they must be
     * included in qpqual.  The upshot is that qpqual must contain
     * scan_clauses minus whatever appears in indexquals.
     *
     * is_redundant_with_indexclauses() detects cases where a scan clause is
     * present in the indexclauses list or is generated from the same
     * EquivalenceClass as some indexclause, and is therefore redundant with
     * it, though not equal.  (The latter happens when indxpath.c prefers a
     * different derived equality than what generate_join_implied_equalities
     * picked for a parameterized scan's ppi_clauses.)  Note that it will not
     * match to lossy index clauses, which is critical because we have to
     * include the original clause in qpqual in that case.
     *
     * In some situations (particularly with OR'd index conditions) we may
     * have scan_clauses that are not equal to, but are logically implied by,
     * the index quals; so we also try a predicate_implied_by() check to see
     * if we can discard quals that way.  (predicate_implied_by assumes its
     * first input contains only immutable functions, so we have to check
     * that.)
     *
     * Note: if you change this bit of code you should also look at
     * extract_nonindex_conditions() in costsize.c.
     */
    qpqual = NIL;
    foreach(l, scan_clauses)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
 
        if (rinfo->pseudoconstant)
            continue;           /* we may drop pseudoconstants here */
        if (is_redundant_with_indexclauses(rinfo, indexclauses))
            continue;           /* dup or derived from same EquivalenceClass */
        if (!contain_mutable_functions((Node *) rinfo->clause) &&
            predicate_implied_by(list_make1(rinfo->clause), stripped_indexquals,
                                 false))
            continue;           /* provably implied by indexquals */
        qpqual = lappend(qpqual, rinfo);
    }
 
    /* Sort clauses into best execution order */
    qpqual = order_qual_clauses(root, qpqual);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    qpqual = extract_actual_clauses(qpqual, false);
 
    /*
     * We have to replace any outer-relation variables with nestloop params in
     * the indexqualorig, qpqual, and indexorderbyorig expressions.  A bit
     * annoying to have to do this separately from the processing in
     * fix_indexqual_references --- rethink this when generalizing the inner
     * indexscan support.  But note we can't really do this earlier because
     * it'd break the comparisons to predicates above ... (or would it?  Those
     * wouldn't have outer refs)
     */
    if (best_path->path.param_info)
    {
        stripped_indexquals = (List *)
            replace_nestloop_params(root, (Node *) stripped_indexquals);
        qpqual = (List *)
            replace_nestloop_params(root, (Node *) qpqual);
        indexorderbys = (List *)
            replace_nestloop_params(root, (Node *) indexorderbys);
    }
 
    /*
     * If there are ORDER BY expressions, look up the sort operators for their
     * result datatypes.
     */
    if (indexorderbys)
    {
        ListCell   *pathkeyCell,
                   *exprCell;
 
        /*
         * PathKey contains OID of the btree opfamily we're sorting by, but
         * that's not quite enough because we need the expression's datatype
         * to look up the sort operator in the operator family.
         */
        Assert(list_length(best_path->path.pathkeys) == list_length(indexorderbys));
        forboth(pathkeyCell, best_path->path.pathkeys, exprCell, indexorderbys)
        {
            PathKey    *pathkey = (PathKey *) lfirst(pathkeyCell);
            Node       *expr = (Node *) lfirst(exprCell);
            Oid         exprtype = exprType(expr);
            Oid         sortop;
 
            /* Get sort operator from opfamily */
            sortop = get_opfamily_member(pathkey->pk_opfamily,
                                         exprtype,
                                         exprtype,
                                         pathkey->pk_strategy);
            if (!OidIsValid(sortop))
                elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                     pathkey->pk_strategy, exprtype, exprtype, pathkey->pk_opfamily);
            indexorderbyops = lappend_oid(indexorderbyops, sortop);
        }
    }
 
    /*
     * For an index-only scan, we must mark indextlist entries as resjunk if
     * they are columns that the index AM can't return; this cues setrefs.c to
     * not generate references to those columns.
     */
    if (indexonly)
    {
        int         i = 0;
 
        foreach(l, indexinfo->indextlist)
        {
            TargetEntry *indextle = (TargetEntry *) lfirst(l);
 
            indextle->resjunk = !indexinfo->canreturn[i];
            i++;
        }
    }
 
    /* Finally ready to build the plan node */
    if (indexonly)
        scan_plan = (Scan *) make_indexonlyscan(tlist,
                                                qpqual,
                                                baserelid,
                                                indexoid,
                                                fixed_indexquals,
                                                stripped_indexquals,
                                                fixed_indexorderbys,
                                                indexinfo->indextlist,
                                                best_path->indexscandir);
    else
        scan_plan = (Scan *) make_indexscan(tlist,
                                            qpqual,
                                            baserelid,
                                            indexoid,
                                            fixed_indexquals,
                                            stripped_indexquals,
                                            fixed_indexorderbys,
                                            indexorderbys,
                                            indexorderbyops,
                                            best_path->indexscandir);
 
    copy_generic_path_info(&scan_plan->plan, &best_path->path);
 
    return scan_plan;
}

References Assert(), BackwardScanDirection, RestrictInfo::clause, contain_mutable_functions(), copy_generic_path_info(), elog(), ERROR, exprType(), extract_actual_clauses(), fix_indexorderby_references(), fix_indexqual_references(), forboth, ForwardScanDirection, get_opfamily_member(), i, IndexPath::indexclauses, IndexPath::indexinfo, IndexOptInfo::indexoid, IndexPath::indexorderbys, IndexPath::indexscandir, IndexOptInfo::indextlist, is_redundant_with_indexclauses(), lappend(), lappend_oid(), lfirst, lfirst_node, list_length(), list_make1, make_indexonlyscan(), make_indexscan(), NIL, OidIsValid, order_qual_clauses(), IndexPath::path, Path::pathkeys, PathKey::pk_opfamily, PathKey::pk_strategy, predicate_implied_by(), replace_nestloop_params(), and RTE_RELATION.

Referenced by create_bitmap_subplan(), and create_scan_plan().

create_join_plan()

static Plan * create_join_plan ( PlannerInfo *  root, JoinPath *  best_path  )

static

Definition at line 1079 of file createplan.c.

{
    Plan       *plan;
    List       *gating_clauses;
 
    switch (best_path->path.pathtype)
    {
        case T_MergeJoin:
            plan = (Plan *) create_mergejoin_plan(root,
                                                  (MergePath *) best_path);
            break;
        case T_HashJoin:
            plan = (Plan *) create_hashjoin_plan(root,
                                                 (HashPath *) best_path);
            break;
        case T_NestLoop:
            plan = (Plan *) create_nestloop_plan(root,
                                                 (NestPath *) best_path);
            break;
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) best_path->path.pathtype);
            plan = NULL;        /* keep compiler quiet */
            break;
    }
 
    /*
     * If there are any pseudoconstant clauses attached to this node, insert a
     * gating Result node that evaluates the pseudoconstants as one-time
     * quals.
     */
    gating_clauses = get_gating_quals(root, best_path->joinrestrictinfo);
    if (gating_clauses)
        plan = create_gating_plan(root, (Path *) best_path, plan,
                                  gating_clauses);
 
#ifdef NOT_USED
 
    /*
     * * Expensive function pullups may have pulled local predicates * into
     * this path node.  Put them in the qpqual of the plan node. * JMH,
     * 6/15/92
     */
    if (get_loc_restrictinfo(best_path) != NIL)
        set_qpqual((Plan) plan,
                   list_concat(get_qpqual((Plan) plan),
                               get_actual_clauses(get_loc_restrictinfo(best_path))));
#endif
 
    return plan;
}

References create_gating_plan(), create_hashjoin_plan(), create_mergejoin_plan(), create_nestloop_plan(), elog(), ERROR, get_actual_clauses(), get_gating_quals(), JoinPath::joinrestrictinfo, list_concat(), NIL, and plan.

Referenced by create_plan_recurse().

create_limit_plan()

static Limit * create_limit_plan ( PlannerInfo *  root, LimitPath *  best_path, int  flags  )

static

Definition at line 2852 of file createplan.c.

{
    Limit      *plan;
    Plan       *subplan;
    int         numUniqkeys = 0;
    AttrNumber *uniqColIdx = NULL;
    Oid        *uniqOperators = NULL;
    Oid        *uniqCollations = NULL;
 
    /* Limit doesn't project, so tlist requirements pass through */
    subplan = create_plan_recurse(root, best_path->subpath, flags);
 
    /* Extract information necessary for comparing rows for WITH TIES. */
    if (best_path->limitOption == LIMIT_OPTION_WITH_TIES)
    {
        Query      *parse = root->parse;
        ListCell   *l;
 
        numUniqkeys = list_length(parse->sortClause);
        uniqColIdx = (AttrNumber *) palloc(numUniqkeys * sizeof(AttrNumber));
        uniqOperators = (Oid *) palloc(numUniqkeys * sizeof(Oid));
        uniqCollations = (Oid *) palloc(numUniqkeys * sizeof(Oid));
 
        numUniqkeys = 0;
        foreach(l, parse->sortClause)
        {
            SortGroupClause *sortcl = (SortGroupClause *) lfirst(l);
            TargetEntry *tle = get_sortgroupclause_tle(sortcl, parse->targetList);
 
            uniqColIdx[numUniqkeys] = tle->resno;
            uniqOperators[numUniqkeys] = sortcl->eqop;
            uniqCollations[numUniqkeys] = exprCollation((Node *) tle->expr);
            numUniqkeys++;
        }
    }
 
    plan = make_limit(subplan,
                      best_path->limitOffset,
                      best_path->limitCount,
                      best_path->limitOption,
                      numUniqkeys, uniqColIdx, uniqOperators, uniqCollations);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), create_plan_recurse(), SortGroupClause::eqop, TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, LIMIT_OPTION_WITH_TIES, LimitPath::limitCount, LimitPath::limitOffset, LimitPath::limitOption, list_length(), make_limit(), palloc(), parse(), PlannerInfo::parse, plan, TargetEntry::resno, and LimitPath::subpath.

Referenced by create_plan_recurse().

create_lockrows_plan()

static LockRows * create_lockrows_plan ( PlannerInfo *  root, LockRowsPath *  best_path, int  flags  )

static

Definition at line 2789 of file createplan.c.

{
    LockRows   *plan;
    Plan       *subplan;
 
    /* LockRows doesn't project, so tlist requirements pass through */
    subplan = create_plan_recurse(root, best_path->subpath, flags);
 
    plan = make_lockrows(subplan, best_path->rowMarks, best_path->epqParam);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), create_plan_recurse(), LockRowsPath::epqParam, make_lockrows(), plan, LockRowsPath::rowMarks, and LockRowsPath::subpath.

Referenced by create_plan_recurse().

create_material_plan()

static Material * create_material_plan ( PlannerInfo *  root, MaterialPath *  best_path, int  flags  )

static

Definition at line 1636 of file createplan.c.

{
    Material   *plan;
    Plan       *subplan;
 
    /*
     * We don't want any excess columns in the materialized tuples, so request
     * a smaller tlist.  Otherwise, since Material doesn't project, tlist
     * requirements pass through.
     */
    subplan = create_plan_recurse(root, best_path->subpath,
                                  flags | CP_SMALL_TLIST);
 
    plan = make_material(subplan);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), CP_SMALL_TLIST, create_plan_recurse(), make_material(), plan, and MaterialPath::subpath.

Referenced by create_plan_recurse().

create_memoize_plan()

static Memoize * create_memoize_plan ( PlannerInfo *  root, MemoizePath *  best_path, int  flags  )

static

Definition at line 1664 of file createplan.c.

{
    Memoize    *plan;
    Bitmapset  *keyparamids;
    Plan       *subplan;
    Oid        *operators;
    Oid        *collations;
    List       *param_exprs = NIL;
    ListCell   *lc;
    ListCell   *lc2;
    int         nkeys;
    int         i;
 
    subplan = create_plan_recurse(root, best_path->subpath,
                                  flags | CP_SMALL_TLIST);
 
    param_exprs = (List *) replace_nestloop_params(root, (Node *)
                                                   best_path->param_exprs);
 
    nkeys = list_length(param_exprs);
    Assert(nkeys > 0);
    operators = palloc(nkeys * sizeof(Oid));
    collations = palloc(nkeys * sizeof(Oid));
 
    i = 0;
    forboth(lc, param_exprs, lc2, best_path->hash_operators)
    {
        Expr       *param_expr = (Expr *) lfirst(lc);
        Oid         opno = lfirst_oid(lc2);
 
        operators[i] = opno;
        collations[i] = exprCollation((Node *) param_expr);
        i++;
    }
 
    keyparamids = pull_paramids((Expr *) param_exprs);
 
    plan = make_memoize(subplan, operators, collations, param_exprs,
                        best_path->singlerow, best_path->binary_mode,
                        best_path->est_entries, keyparamids);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References Assert(), MemoizePath::binary_mode, copy_generic_path_info(), CP_SMALL_TLIST, create_plan_recurse(), MemoizePath::est_entries, exprCollation(), forboth, MemoizePath::hash_operators, i, lfirst, lfirst_oid, list_length(), make_memoize(), NIL, palloc(), MemoizePath::param_exprs, plan, pull_paramids(), replace_nestloop_params(), MemoizePath::singlerow, and MemoizePath::subpath.

Referenced by create_plan_recurse().

create_merge_append_plan()

static Plan * create_merge_append_plan ( PlannerInfo *  root, MergeAppendPath *  best_path, int  flags  )

static

Definition at line 1435 of file createplan.c.

{
    MergeAppend *node = makeNode(MergeAppend);
    Plan       *plan = &node->plan;
    List       *tlist = build_path_tlist(root, &best_path->path);
    int         orig_tlist_length = list_length(tlist);
    bool        tlist_was_changed;
    List       *pathkeys = best_path->path.pathkeys;
    List       *subplans = NIL;
    ListCell   *subpaths;
    RelOptInfo *rel = best_path->path.parent;
    PartitionPruneInfo *partpruneinfo = NULL;
 
    /*
     * We don't have the actual creation of the MergeAppend node split out
     * into a separate make_xxx function.  This is because we want to run
     * prepare_sort_from_pathkeys on it before we do so on the individual
     * child plans, to make cross-checking the sort info easier.
     */
    copy_generic_path_info(plan, (Path *) best_path);
    plan->targetlist = tlist;
    plan->qual = NIL;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->apprelids = rel->relids;
 
    /*
     * Compute sort column info, and adjust MergeAppend's tlist as needed.
     * Because we pass adjust_tlist_in_place = true, we may ignore the
     * function result; it must be the same plan node.  However, we then need
     * to detect whether any tlist entries were added.
     */
    (void) prepare_sort_from_pathkeys(plan, pathkeys,
                                      best_path->path.parent->relids,
                                      NULL,
                                      true,
                                      &node->numCols,
                                      &node->sortColIdx,
                                      &node->sortOperators,
                                      &node->collations,
                                      &node->nullsFirst);
    tlist_was_changed = (orig_tlist_length != list_length(plan->targetlist));
 
    /*
     * Now prepare the child plans.  We must apply prepare_sort_from_pathkeys
     * even to subplans that don't need an explicit sort, to make sure they
     * are returning the same sort key columns the MergeAppend expects.
     */
    foreach(subpaths, best_path->subpaths)
    {
        Path       *subpath = (Path *) lfirst(subpaths);
        Plan       *subplan;
        int         numsortkeys;
        AttrNumber *sortColIdx;
        Oid        *sortOperators;
        Oid        *collations;
        bool       *nullsFirst;
 
        /* Build the child plan */
        /* Must insist that all children return the same tlist */
        subplan = create_plan_recurse(root, subpath, CP_EXACT_TLIST);
 
        /* Compute sort column info, and adjust subplan's tlist as needed */
        subplan = prepare_sort_from_pathkeys(subplan, pathkeys,
                                             subpath->parent->relids,
                                             node->sortColIdx,
                                             false,
                                             &numsortkeys,
                                             &sortColIdx,
                                             &sortOperators,
                                             &collations,
                                             &nullsFirst);
 
        /*
         * Check that we got the same sort key information.  We just Assert
         * that the sortops match, since those depend only on the pathkeys;
         * but it seems like a good idea to check the sort column numbers
         * explicitly, to ensure the tlists really do match up.
         */
        Assert(numsortkeys == node->numCols);
        if (memcmp(sortColIdx, node->sortColIdx,
                   numsortkeys * sizeof(AttrNumber)) != 0)
            elog(ERROR, "MergeAppend child's targetlist doesn't match MergeAppend");
        Assert(memcmp(sortOperators, node->sortOperators,
                      numsortkeys * sizeof(Oid)) == 0);
        Assert(memcmp(collations, node->collations,
                      numsortkeys * sizeof(Oid)) == 0);
        Assert(memcmp(nullsFirst, node->nullsFirst,
                      numsortkeys * sizeof(bool)) == 0);
 
        /* Now, insert a Sort node if subplan isn't sufficiently ordered */
        if (!pathkeys_contained_in(pathkeys, subpath->pathkeys))
        {
            Sort       *sort = make_sort(subplan, numsortkeys,
                                         sortColIdx, sortOperators,
                                         collations, nullsFirst);
 
            label_sort_with_costsize(root, sort, best_path->limit_tuples);
            subplan = (Plan *) sort;
        }
 
        subplans = lappend(subplans, subplan);
    }
 
    /*
     * If any quals exist, they may be useful to perform further partition
     * pruning during execution.  Gather information needed by the executor to
     * do partition pruning.
     */
    if (enable_partition_pruning)
    {
        List       *prunequal;
 
        prunequal = extract_actual_clauses(rel->baserestrictinfo, false);
 
        /* We don't currently generate any parameterized MergeAppend paths */
        Assert(best_path->path.param_info == NULL);
 
        if (prunequal != NIL)
            partpruneinfo = make_partition_pruneinfo(root, rel,
                                                     best_path->subpaths,
                                                     prunequal);
    }
 
    node->mergeplans = subplans;
    node->part_prune_info = partpruneinfo;
 
    /*
     * If prepare_sort_from_pathkeys added sort columns, but we were told to
     * produce either the exact tlist or a narrow tlist, we should get rid of
     * the sort columns again.  We must inject a projection node to do so.
     */
    if (tlist_was_changed && (flags & (CP_EXACT_TLIST | CP_SMALL_TLIST)))
    {
        tlist = list_copy_head(plan->targetlist, orig_tlist_length);
        return inject_projection_plan(plan, tlist, plan->parallel_safe);
    }
    else
        return plan;
}

References MergeAppend::apprelids, Assert(), RelOptInfo::baserestrictinfo, build_path_tlist(), copy_generic_path_info(), CP_EXACT_TLIST, CP_SMALL_TLIST, create_plan_recurse(), elog(), enable_partition_pruning, ERROR, extract_actual_clauses(), inject_projection_plan(), label_sort_with_costsize(), lappend(), lfirst, MergeAppendPath::limit_tuples, list_copy_head(), list_length(), make_partition_pruneinfo(), make_sort(), makeNode, MergeAppend::mergeplans, NIL, MergeAppend::numCols, MergeAppend::part_prune_info, MergeAppendPath::path, Path::pathkeys, pathkeys_contained_in(), MergeAppend::plan, plan, prepare_sort_from_pathkeys(), RelOptInfo::relids, sort(), subpath(), and MergeAppendPath::subpaths.

Referenced by create_plan_recurse().

create_mergejoin_plan()

static MergeJoin * create_mergejoin_plan ( PlannerInfo *  root, MergePath *  best_path  )

static

Definition at line 4411 of file createplan.c.

{
    MergeJoin  *join_plan;
    Plan       *outer_plan;
    Plan       *inner_plan;
    List       *tlist = build_path_tlist(root, &best_path->jpath.path);
    List       *joinclauses;
    List       *otherclauses;
    List       *mergeclauses;
    List       *outerpathkeys;
    List       *innerpathkeys;
    int         nClauses;
    Oid        *mergefamilies;
    Oid        *mergecollations;
    int        *mergestrategies;
    bool       *mergenullsfirst;
    PathKey    *opathkey;
    EquivalenceClass *opeclass;
    int         i;
    ListCell   *lc;
    ListCell   *lop;
    ListCell   *lip;
    Path       *outer_path = best_path->jpath.outerjoinpath;
    Path       *inner_path = best_path->jpath.innerjoinpath;
 
    /*
     * MergeJoin can project, so we don't have to demand exact tlists from the
     * inputs.  However, if we're intending to sort an input's result, it's
     * best to request a small tlist so we aren't sorting more data than
     * necessary.
     */
    outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath,
                                     (best_path->outersortkeys != NIL) ? CP_SMALL_TLIST : 0);
 
    inner_plan = create_plan_recurse(root, best_path->jpath.innerjoinpath,
                                     (best_path->innersortkeys != NIL) ? CP_SMALL_TLIST : 0);
 
    /* Sort join qual clauses into best execution order */
    /* NB: do NOT reorder the mergeclauses */
    joinclauses = order_qual_clauses(root, best_path->jpath.joinrestrictinfo);
 
    /* Get the join qual clauses (in plain expression form) */
    /* Any pseudoconstant clauses are ignored here */
    if (IS_OUTER_JOIN(best_path->jpath.jointype))
    {
        extract_actual_join_clauses(joinclauses,
                                    best_path->jpath.path.parent->relids,
                                    &joinclauses, &otherclauses);
    }
    else
    {
        /* We can treat all clauses alike for an inner join */
        joinclauses = extract_actual_clauses(joinclauses, false);
        otherclauses = NIL;
    }
 
    /*
     * Remove the mergeclauses from the list of join qual clauses, leaving the
     * list of quals that must be checked as qpquals.
     */
    mergeclauses = get_actual_clauses(best_path->path_mergeclauses);
    joinclauses = list_difference(joinclauses, mergeclauses);
 
    /*
     * Replace any outer-relation variables with nestloop params.  There
     * should not be any in the mergeclauses.
     */
    if (best_path->jpath.path.param_info)
    {
        joinclauses = (List *)
            replace_nestloop_params(root, (Node *) joinclauses);
        otherclauses = (List *)
            replace_nestloop_params(root, (Node *) otherclauses);
    }
 
    /*
     * Rearrange mergeclauses, if needed, so that the outer variable is always
     * on the left; mark the mergeclause restrictinfos with correct
     * outer_is_left status.
     */
    mergeclauses = get_switched_clauses(best_path->path_mergeclauses,
                                        best_path->jpath.outerjoinpath->parent->relids);
 
    /*
     * Create explicit sort nodes for the outer and inner paths if necessary.
     */
    if (best_path->outersortkeys)
    {
        Relids      outer_relids = outer_path->parent->relids;
        Sort       *sort = make_sort_from_pathkeys(outer_plan,
                                                   best_path->outersortkeys,
                                                   outer_relids);
 
        label_sort_with_costsize(root, sort, -1.0);
        outer_plan = (Plan *) sort;
        outerpathkeys = best_path->outersortkeys;
    }
    else
        outerpathkeys = best_path->jpath.outerjoinpath->pathkeys;
 
    if (best_path->innersortkeys)
    {
        Relids      inner_relids = inner_path->parent->relids;
        Sort       *sort = make_sort_from_pathkeys(inner_plan,
                                                   best_path->innersortkeys,
                                                   inner_relids);
 
        label_sort_with_costsize(root, sort, -1.0);
        inner_plan = (Plan *) sort;
        innerpathkeys = best_path->innersortkeys;
    }
    else
        innerpathkeys = best_path->jpath.innerjoinpath->pathkeys;
 
    /*
     * If specified, add a materialize node to shield the inner plan from the
     * need to handle mark/restore.
     */
    if (best_path->materialize_inner)
    {
        Plan       *matplan = (Plan *) make_material(inner_plan);
 
        /*
         * We assume the materialize will not spill to disk, and therefore
         * charge just cpu_operator_cost per tuple.  (Keep this estimate in
         * sync with final_cost_mergejoin.)
         */
        copy_plan_costsize(matplan, inner_plan);
        matplan->total_cost += cpu_operator_cost * matplan->plan_rows;
 
        inner_plan = matplan;
    }
 
    /*
     * Compute the opfamily/collation/strategy/nullsfirst arrays needed by the
     * executor.  The information is in the pathkeys for the two inputs, but
     * we need to be careful about the possibility of mergeclauses sharing a
     * pathkey, as well as the possibility that the inner pathkeys are not in
     * an order matching the mergeclauses.
     */
    nClauses = list_length(mergeclauses);
    Assert(nClauses == list_length(best_path->path_mergeclauses));
    mergefamilies = (Oid *) palloc(nClauses * sizeof(Oid));
    mergecollations = (Oid *) palloc(nClauses * sizeof(Oid));
    mergestrategies = (int *) palloc(nClauses * sizeof(int));
    mergenullsfirst = (bool *) palloc(nClauses * sizeof(bool));
 
    opathkey = NULL;
    opeclass = NULL;
    lop = list_head(outerpathkeys);
    lip = list_head(innerpathkeys);
    i = 0;
    foreach(lc, best_path->path_mergeclauses)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
        EquivalenceClass *oeclass;
        EquivalenceClass *ieclass;
        PathKey    *ipathkey = NULL;
        EquivalenceClass *ipeclass = NULL;
        bool        first_inner_match = false;
 
        /* fetch outer/inner eclass from mergeclause */
        if (rinfo->outer_is_left)
        {
            oeclass = rinfo->left_ec;
            ieclass = rinfo->right_ec;
        }
        else
        {
            oeclass = rinfo->right_ec;
            ieclass = rinfo->left_ec;
        }
        Assert(oeclass != NULL);
        Assert(ieclass != NULL);
 
        /*
         * We must identify the pathkey elements associated with this clause
         * by matching the eclasses (which should give a unique match, since
         * the pathkey lists should be canonical).  In typical cases the merge
         * clauses are one-to-one with the pathkeys, but when dealing with
         * partially redundant query conditions, things are more complicated.
         *
         * lop and lip reference the first as-yet-unmatched pathkey elements.
         * If they're NULL then all pathkey elements have been matched.
         *
         * The ordering of the outer pathkeys should match the mergeclauses,
         * by construction (see find_mergeclauses_for_outer_pathkeys()). There
         * could be more than one mergeclause for the same outer pathkey, but
         * no pathkey may be entirely skipped over.
         */
        if (oeclass != opeclass)    /* multiple matches are not interesting */
        {
            /* doesn't match the current opathkey, so must match the next */
            if (lop == NULL)
                elog(ERROR, "outer pathkeys do not match mergeclauses");
            opathkey = (PathKey *) lfirst(lop);
            opeclass = opathkey->pk_eclass;
            lop = lnext(outerpathkeys, lop);
            if (oeclass != opeclass)
                elog(ERROR, "outer pathkeys do not match mergeclauses");
        }
 
        /*
         * The inner pathkeys likewise should not have skipped-over keys, but
         * it's possible for a mergeclause to reference some earlier inner
         * pathkey if we had redundant pathkeys.  For example we might have
         * mergeclauses like "o.a = i.x AND o.b = i.y AND o.c = i.x".  The
         * implied inner ordering is then "ORDER BY x, y, x", but the pathkey
         * mechanism drops the second sort by x as redundant, and this code
         * must cope.
         *
         * It's also possible for the implied inner-rel ordering to be like
         * "ORDER BY x, y, x DESC".  We still drop the second instance of x as
         * redundant; but this means that the sort ordering of a redundant
         * inner pathkey should not be considered significant.  So we must
         * detect whether this is the first clause matching an inner pathkey.
         */
        if (lip)
        {
            ipathkey = (PathKey *) lfirst(lip);
            ipeclass = ipathkey->pk_eclass;
            if (ieclass == ipeclass)
            {
                /* successful first match to this inner pathkey */
                lip = lnext(innerpathkeys, lip);
                first_inner_match = true;
            }
        }
        if (!first_inner_match)
        {
            /* redundant clause ... must match something before lip */
            ListCell   *l2;
 
            foreach(l2, innerpathkeys)
            {
                if (l2 == lip)
                    break;
                ipathkey = (PathKey *) lfirst(l2);
                ipeclass = ipathkey->pk_eclass;
                if (ieclass == ipeclass)
                    break;
            }
            if (ieclass != ipeclass)
                elog(ERROR, "inner pathkeys do not match mergeclauses");
        }
 
        /*
         * The pathkeys should always match each other as to opfamily and
         * collation (which affect equality), but if we're considering a
         * redundant inner pathkey, its sort ordering might not match.  In
         * such cases we may ignore the inner pathkey's sort ordering and use
         * the outer's.  (In effect, we're lying to the executor about the
         * sort direction of this inner column, but it does not matter since
         * the run-time row comparisons would only reach this column when
         * there's equality for the earlier column containing the same eclass.
         * There could be only one value in this column for the range of inner
         * rows having a given value in the earlier column, so it does not
         * matter which way we imagine this column to be ordered.)  But a
         * non-redundant inner pathkey had better match outer's ordering too.
         */
        if (opathkey->pk_opfamily != ipathkey->pk_opfamily ||
            opathkey->pk_eclass->ec_collation != ipathkey->pk_eclass->ec_collation)
            elog(ERROR, "left and right pathkeys do not match in mergejoin");
        if (first_inner_match &&
            (opathkey->pk_strategy != ipathkey->pk_strategy ||
             opathkey->pk_nulls_first != ipathkey->pk_nulls_first))
            elog(ERROR, "left and right pathkeys do not match in mergejoin");
 
        /* OK, save info for executor */
        mergefamilies[i] = opathkey->pk_opfamily;
        mergecollations[i] = opathkey->pk_eclass->ec_collation;
        mergestrategies[i] = opathkey->pk_strategy;
        mergenullsfirst[i] = opathkey->pk_nulls_first;
        i++;
    }
 
    /*
     * Note: it is not an error if we have additional pathkey elements (i.e.,
     * lop or lip isn't NULL here).  The input paths might be better-sorted
     * than we need for the current mergejoin.
     */
 
    /*
     * Now we can build the mergejoin node.
     */
    join_plan = make_mergejoin(tlist,
                               joinclauses,
                               otherclauses,
                               mergeclauses,
                               mergefamilies,
                               mergecollations,
                               mergestrategies,
                               mergenullsfirst,
                               outer_plan,
                               inner_plan,
                               best_path->jpath.jointype,
                               best_path->jpath.inner_unique,
                               best_path->skip_mark_restore);
 
    /* Costs of sort and material steps are included in path cost already */
    copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
 
    return join_plan;
}

References Assert(), build_path_tlist(), copy_generic_path_info(), copy_plan_costsize(), CP_SMALL_TLIST, cpu_operator_cost, create_plan_recurse(), elog(), ERROR, extract_actual_clauses(), extract_actual_join_clauses(), get_actual_clauses(), get_switched_clauses(), i, JoinPath::inner_unique, JoinPath::innerjoinpath, MergePath::innersortkeys, IS_OUTER_JOIN, MergeJoin::join, JoinPath::joinrestrictinfo, JoinPath::jointype, MergePath::jpath, label_sort_with_costsize(), lfirst, lfirst_node, list_difference(), list_head(), list_length(), lnext(), make_material(), make_mergejoin(), make_sort_from_pathkeys(), MergePath::materialize_inner, NIL, order_qual_clauses(), JoinPath::outerjoinpath, MergePath::outersortkeys, palloc(), MergePath::path_mergeclauses, Path::pathkeys, PathKey::pk_nulls_first, PathKey::pk_opfamily, PathKey::pk_strategy, Plan::plan_rows, replace_nestloop_params(), MergePath::skip_mark_restore, sort(), and Plan::total_cost.

Referenced by create_join_plan().

create_minmaxagg_plan()

static Result * create_minmaxagg_plan ( PlannerInfo *  root, MinMaxAggPath *  best_path  )

static

Definition at line 2548 of file createplan.c.

{
    Result     *plan;
    List       *tlist;
    ListCell   *lc;
 
    /* Prepare an InitPlan for each aggregate's subquery. */
    foreach(lc, best_path->mmaggregates)
    {
        MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
        PlannerInfo *subroot = mminfo->subroot;
        Query      *subparse = subroot->parse;
        Plan       *plan;
 
        /*
         * Generate the plan for the subquery. We already have a Path, but we
         * have to convert it to a Plan and attach a LIMIT node above it.
         * Since we are entering a different planner context (subroot),
         * recurse to create_plan not create_plan_recurse.
         */
        plan = create_plan(subroot, mminfo->path);
 
        plan = (Plan *) make_limit(plan,
                                   subparse->limitOffset,
                                   subparse->limitCount,
                                   subparse->limitOption,
                                   0, NULL, NULL, NULL);
 
        /* Must apply correct cost/width data to Limit node */
        plan->startup_cost = mminfo->path->startup_cost;
        plan->total_cost = mminfo->pathcost;
        plan->plan_rows = 1;
        plan->plan_width = mminfo->path->pathtarget->width;
        plan->parallel_aware = false;
        plan->parallel_safe = mminfo->path->parallel_safe;
 
        /* Convert the plan into an InitPlan in the outer query. */
        SS_make_initplan_from_plan(root, subroot, plan, mminfo->param);
    }
 
    /* Generate the output plan --- basically just a Result */
    tlist = build_path_tlist(root, &best_path->path);
 
    plan = make_result(tlist, (Node *) best_path->quals, NULL);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    /*
     * During setrefs.c, we'll need to replace references to the Agg nodes
     * with InitPlan output params.  (We can't just do that locally in the
     * MinMaxAgg node, because path nodes above here may have Agg references
     * as well.)  Save the mmaggregates list to tell setrefs.c to do that.
     */
    Assert(root->minmax_aggs == NIL);
    root->minmax_aggs = best_path->mmaggregates;
 
    return plan;
}

References Assert(), build_path_tlist(), copy_generic_path_info(), create_plan(), lfirst, Query::limitCount, Query::limitOffset, Query::limitOption, make_limit(), make_result(), PlannerInfo::minmax_aggs, MinMaxAggPath::mmaggregates, NIL, Path::parallel_safe, MinMaxAggInfo::param, PlannerInfo::parse, MinMaxAggPath::path, MinMaxAggInfo::path, MinMaxAggInfo::pathcost, plan, MinMaxAggPath::quals, SS_make_initplan_from_plan(), and Path::startup_cost.

Referenced by create_plan_recurse().

create_modifytable_plan()

static ModifyTable * create_modifytable_plan ( PlannerInfo *  root, ModifyTablePath *  best_path  )

static

Definition at line 2812 of file createplan.c.

{
    ModifyTable *plan;
    Path       *subpath = best_path->subpath;
    Plan       *subplan;
 
    /* Subplan must produce exactly the specified tlist */
    subplan = create_plan_recurse(root, subpath, CP_EXACT_TLIST);
 
    /* Transfer resname/resjunk labeling, too, to keep executor happy */
    apply_tlist_labeling(subplan->targetlist, root->processed_tlist);
 
    plan = make_modifytable(root,
                            subplan,
                            best_path->operation,
                            best_path->canSetTag,
                            best_path->nominalRelation,
                            best_path->rootRelation,
                            best_path->partColsUpdated,
                            best_path->resultRelations,
                            best_path->updateColnosLists,
                            best_path->withCheckOptionLists,
                            best_path->returningLists,
                            best_path->rowMarks,
                            best_path->onconflict,
                            best_path->mergeActionLists,
                            best_path->epqParam);
 
    copy_generic_path_info(&plan->plan, &best_path->path);
 
    return plan;
}

References apply_tlist_labeling(), ModifyTablePath::canSetTag, copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), ModifyTablePath::epqParam, make_modifytable(), ModifyTablePath::mergeActionLists, ModifyTablePath::nominalRelation, ModifyTablePath::onconflict, ModifyTablePath::operation, ModifyTablePath::partColsUpdated, ModifyTablePath::path, plan, PlannerInfo::processed_tlist, ModifyTablePath::resultRelations, ModifyTablePath::returningLists, ModifyTablePath::rootRelation, ModifyTablePath::rowMarks, subpath(), ModifyTablePath::subpath, Plan::targetlist, ModifyTablePath::updateColnosLists, and ModifyTablePath::withCheckOptionLists.

Referenced by create_plan_recurse().

create_namedtuplestorescan_plan()

static NamedTuplestoreScan * create_namedtuplestorescan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3973 of file createplan.c.

{
    NamedTuplestoreScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
 
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_NAMEDTUPLESTORE);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_namedtuplestorescan(tlist, scan_clauses, scan_relid,
                                         rte->enrname);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), RangeTblEntry::enrname, extract_actual_clauses(), make_namedtuplestorescan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), RTE_NAMEDTUPLESTORE, RangeTblEntry::rtekind, and NamedTuplestoreScan::scan.

Referenced by create_scan_plan().

create_nestloop_plan()

static NestLoop * create_nestloop_plan ( PlannerInfo *  root, NestPath *  best_path  )

static

Definition at line 4335 of file createplan.c.

{
    NestLoop   *join_plan;
    Plan       *outer_plan;
    Plan       *inner_plan;
    List       *tlist = build_path_tlist(root, &best_path->jpath.path);
    List       *joinrestrictclauses = best_path->jpath.joinrestrictinfo;
    List       *joinclauses;
    List       *otherclauses;
    Relids      outerrelids;
    List       *nestParams;
    Relids      saveOuterRels = root->curOuterRels;
 
    /* NestLoop can project, so no need to be picky about child tlists */
    outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath, 0);
 
    /* For a nestloop, include outer relids in curOuterRels for inner side */
    root->curOuterRels = bms_union(root->curOuterRels,
                                   best_path->jpath.outerjoinpath->parent->relids);
 
    inner_plan = create_plan_recurse(root, best_path->jpath.innerjoinpath, 0);
 
    /* Restore curOuterRels */
    bms_free(root->curOuterRels);
    root->curOuterRels = saveOuterRels;
 
    /* Sort join qual clauses into best execution order */
    joinrestrictclauses = order_qual_clauses(root, joinrestrictclauses);
 
    /* Get the join qual clauses (in plain expression form) */
    /* Any pseudoconstant clauses are ignored here */
    if (IS_OUTER_JOIN(best_path->jpath.jointype))
    {
        extract_actual_join_clauses(joinrestrictclauses,
                                    best_path->jpath.path.parent->relids,
                                    &joinclauses, &otherclauses);
    }
    else
    {
        /* We can treat all clauses alike for an inner join */
        joinclauses = extract_actual_clauses(joinrestrictclauses, false);
        otherclauses = NIL;
    }
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->jpath.path.param_info)
    {
        joinclauses = (List *)
            replace_nestloop_params(root, (Node *) joinclauses);
        otherclauses = (List *)
            replace_nestloop_params(root, (Node *) otherclauses);
    }
 
    /*
     * Identify any nestloop parameters that should be supplied by this join
     * node, and remove them from root->curOuterParams.
     */
    outerrelids = best_path->jpath.outerjoinpath->parent->relids;
    nestParams = identify_current_nestloop_params(root, outerrelids);
 
    join_plan = make_nestloop(tlist,
                              joinclauses,
                              otherclauses,
                              nestParams,
                              outer_plan,
                              inner_plan,
                              best_path->jpath.jointype,
                              best_path->jpath.inner_unique);
 
    copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
 
    return join_plan;
}

References bms_free(), bms_union(), build_path_tlist(), copy_generic_path_info(), create_plan_recurse(), PlannerInfo::curOuterRels, extract_actual_clauses(), extract_actual_join_clauses(), identify_current_nestloop_params(), JoinPath::inner_unique, JoinPath::innerjoinpath, IS_OUTER_JOIN, NestLoop::join, JoinPath::joinrestrictinfo, JoinPath::jointype, NestPath::jpath, make_nestloop(), NIL, order_qual_clauses(), JoinPath::outerjoinpath, and replace_nestloop_params().

Referenced by create_join_plan().

create_plan()

Plan* create_plan	(	PlannerInfo *	root,
		Path *	best_path
	)

Definition at line 335 of file createplan.c.

{
    Plan       *plan;
 
    /* plan_params should not be in use in current query level */
    Assert(root->plan_params == NIL);
 
    /* Initialize this module's workspace in PlannerInfo */
    root->curOuterRels = NULL;
    root->curOuterParams = NIL;
 
    /* Recursively process the path tree, demanding the correct tlist result */
    plan = create_plan_recurse(root, best_path, CP_EXACT_TLIST);
 
    /*
     * Make sure the topmost plan node's targetlist exposes the original
     * column names and other decorative info.  Targetlists generated within
     * the planner don't bother with that stuff, but we must have it on the
     * top-level tlist seen at execution time.  However, ModifyTable plan
     * nodes don't have a tlist matching the querytree targetlist.
     */
    if (!IsA(plan, ModifyTable))
        apply_tlist_labeling(plan->targetlist, root->processed_tlist);
 
    /*
     * Attach any initPlans created in this query level to the topmost plan
     * node.  (In principle the initplans could go in any plan node at or
     * above where they're referenced, but there seems no reason to put them
     * any lower than the topmost node for the query level.  Also, see
     * comments for SS_finalize_plan before you try to change this.)
     */
    SS_attach_initplans(root, plan);
 
    /* Check we successfully assigned all NestLoopParams to plan nodes */
    if (root->curOuterParams != NIL)
        elog(ERROR, "failed to assign all NestLoopParams to plan nodes");
 
    /*
     * Reset plan_params to ensure param IDs used for nestloop params are not
     * re-used later
     */
    root->plan_params = NIL;
 
    return plan;
}

References apply_tlist_labeling(), Assert(), CP_EXACT_TLIST, create_plan_recurse(), PlannerInfo::curOuterParams, PlannerInfo::curOuterRels, elog(), ERROR, IsA, NIL, plan, PlannerInfo::plan_params, PlannerInfo::processed_tlist, and SS_attach_initplans().

Referenced by create_minmaxagg_plan(), create_subqueryscan_plan(), make_subplan(), SS_process_ctes(), and standard_planner().

create_plan_recurse()

static Plan * create_plan_recurse ( PlannerInfo *  root, Path *  best_path, int  flags  )

static

Definition at line 386 of file createplan.c.

{
    Plan       *plan;
 
    /* Guard against stack overflow due to overly complex plans */
    check_stack_depth();
 
    switch (best_path->pathtype)
    {
        case T_SeqScan:
        case T_SampleScan:
        case T_IndexScan:
        case T_IndexOnlyScan:
        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_WorkTableScan:
        case T_NamedTuplestoreScan:
        case T_ForeignScan:
        case T_CustomScan:
            plan = create_scan_plan(root, best_path, flags);
            break;
        case T_HashJoin:
        case T_MergeJoin:
        case T_NestLoop:
            plan = create_join_plan(root,
                                    (JoinPath *) best_path);
            break;
        case T_Append:
            plan = create_append_plan(root,
                                      (AppendPath *) best_path,
                                      flags);
            break;
        case T_MergeAppend:
            plan = create_merge_append_plan(root,
                                            (MergeAppendPath *) best_path,
                                            flags);
            break;
        case T_Result:
            if (IsA(best_path, ProjectionPath))
            {
                plan = create_projection_plan(root,
                                              (ProjectionPath *) best_path,
                                              flags);
            }
            else if (IsA(best_path, MinMaxAggPath))
            {
                plan = (Plan *) create_minmaxagg_plan(root,
                                                      (MinMaxAggPath *) best_path);
            }
            else if (IsA(best_path, GroupResultPath))
            {
                plan = (Plan *) create_group_result_plan(root,
                                                         (GroupResultPath *) best_path);
            }
            else
            {
                /* Simple RTE_RESULT base relation */
                Assert(IsA(best_path, Path));
                plan = create_scan_plan(root, best_path, flags);
            }
            break;
        case T_ProjectSet:
            plan = (Plan *) create_project_set_plan(root,
                                                    (ProjectSetPath *) best_path);
            break;
        case T_Material:
            plan = (Plan *) create_material_plan(root,
                                                 (MaterialPath *) best_path,
                                                 flags);
            break;
        case T_Memoize:
            plan = (Plan *) create_memoize_plan(root,
                                                (MemoizePath *) best_path,
                                                flags);
            break;
        case T_Unique:
            if (IsA(best_path, UpperUniquePath))
            {
                plan = (Plan *) create_upper_unique_plan(root,
                                                         (UpperUniquePath *) best_path,
                                                         flags);
            }
            else
            {
                Assert(IsA(best_path, UniquePath));
                plan = create_unique_plan(root,
                                          (UniquePath *) best_path,
                                          flags);
            }
            break;
        case T_Gather:
            plan = (Plan *) create_gather_plan(root,
                                               (GatherPath *) best_path);
            break;
        case T_Sort:
            plan = (Plan *) create_sort_plan(root,
                                             (SortPath *) best_path,
                                             flags);
            break;
        case T_IncrementalSort:
            plan = (Plan *) create_incrementalsort_plan(root,
                                                        (IncrementalSortPath *) best_path,
                                                        flags);
            break;
        case T_Group:
            plan = (Plan *) create_group_plan(root,
                                              (GroupPath *) best_path);
            break;
        case T_Agg:
            if (IsA(best_path, GroupingSetsPath))
                plan = create_groupingsets_plan(root,
                                                (GroupingSetsPath *) best_path);
            else
            {
                Assert(IsA(best_path, AggPath));
                plan = (Plan *) create_agg_plan(root,
                                                (AggPath *) best_path);
            }
            break;
        case T_WindowAgg:
            plan = (Plan *) create_windowagg_plan(root,
                                                  (WindowAggPath *) best_path);
            break;
        case T_SetOp:
            plan = (Plan *) create_setop_plan(root,
                                              (SetOpPath *) best_path,
                                              flags);
            break;
        case T_RecursiveUnion:
            plan = (Plan *) create_recursiveunion_plan(root,
                                                       (RecursiveUnionPath *) best_path);
            break;
        case T_LockRows:
            plan = (Plan *) create_lockrows_plan(root,
                                                 (LockRowsPath *) best_path,
                                                 flags);
            break;
        case T_ModifyTable:
            plan = (Plan *) create_modifytable_plan(root,
                                                    (ModifyTablePath *) best_path);
            break;
        case T_Limit:
            plan = (Plan *) create_limit_plan(root,
                                              (LimitPath *) best_path,
                                              flags);
            break;
        case T_GatherMerge:
            plan = (Plan *) create_gather_merge_plan(root,
                                                     (GatherMergePath *) best_path);
            break;
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) best_path->pathtype);
            plan = NULL;        /* keep compiler quiet */
            break;
    }
 
    return plan;
}

References Assert(), check_stack_depth(), create_agg_plan(), create_append_plan(), create_gather_merge_plan(), create_gather_plan(), create_group_plan(), create_group_result_plan(), create_groupingsets_plan(), create_incrementalsort_plan(), create_join_plan(), create_limit_plan(), create_lockrows_plan(), create_material_plan(), create_memoize_plan(), create_merge_append_plan(), create_minmaxagg_plan(), create_modifytable_plan(), create_project_set_plan(), create_projection_plan(), create_recursiveunion_plan(), create_scan_plan(), create_setop_plan(), create_sort_plan(), create_unique_plan(), create_upper_unique_plan(), create_windowagg_plan(), elog(), ERROR, IsA, Path::pathtype, and plan.

Referenced by create_agg_plan(), create_append_plan(), create_customscan_plan(), create_foreignscan_plan(), create_gather_merge_plan(), create_gather_plan(), create_group_plan(), create_groupingsets_plan(), create_hashjoin_plan(), create_incrementalsort_plan(), create_limit_plan(), create_lockrows_plan(), create_material_plan(), create_memoize_plan(), create_merge_append_plan(), create_mergejoin_plan(), create_modifytable_plan(), create_nestloop_plan(), create_plan(), create_project_set_plan(), create_projection_plan(), create_recursiveunion_plan(), create_setop_plan(), create_sort_plan(), create_unique_plan(), create_upper_unique_plan(), and create_windowagg_plan().

create_project_set_plan()

static ProjectSet * create_project_set_plan ( PlannerInfo *  root, ProjectSetPath *  best_path  )

static

Definition at line 1610 of file createplan.c.

{
    ProjectSet *plan;
    Plan       *subplan;
    List       *tlist;
 
    /* Since we intend to project, we don't need to constrain child tlist */
    subplan = create_plan_recurse(root, best_path->subpath, 0);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    plan = make_project_set(tlist, subplan);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References build_path_tlist(), copy_generic_path_info(), create_plan_recurse(), make_project_set(), ProjectSetPath::path, plan, and ProjectSetPath::subpath.

Referenced by create_plan_recurse().

create_projection_plan()

static Plan * create_projection_plan ( PlannerInfo *  root, ProjectionPath *  best_path, int  flags  )

static

Definition at line 2016 of file createplan.c.

{
    Plan       *plan;
    Plan       *subplan;
    List       *tlist;
    bool        needs_result_node = false;
 
    /*
     * Convert our subpath to a Plan and determine whether we need a Result
     * node.
     *
     * In most cases where we don't need to project, creation_projection_path
     * will have set dummypp, but not always.  First, some createplan.c
     * routines change the tlists of their nodes.  (An example is that
     * create_merge_append_plan might add resjunk sort columns to a
     * MergeAppend.)  Second, create_projection_path has no way of knowing
     * what path node will be placed on top of the projection path and
     * therefore can't predict whether it will require an exact tlist. For
     * both of these reasons, we have to recheck here.
     */
    if (use_physical_tlist(root, &best_path->path, flags))
    {
        /*
         * Our caller doesn't really care what tlist we return, so we don't
         * actually need to project.  However, we may still need to ensure
         * proper sortgroupref labels, if the caller cares about those.
         */
        subplan = create_plan_recurse(root, best_path->subpath, 0);
        tlist = subplan->targetlist;
        if (flags & CP_LABEL_TLIST)
            apply_pathtarget_labeling_to_tlist(tlist,
                                               best_path->path.pathtarget);
    }
    else if (is_projection_capable_path(best_path->subpath))
    {
        /*
         * Our caller requires that we return the exact tlist, but no separate
         * result node is needed because the subpath is projection-capable.
         * Tell create_plan_recurse that we're going to ignore the tlist it
         * produces.
         */
        subplan = create_plan_recurse(root, best_path->subpath,
                                      CP_IGNORE_TLIST);
        Assert(is_projection_capable_plan(subplan));
        tlist = build_path_tlist(root, &best_path->path);
    }
    else
    {
        /*
         * It looks like we need a result node, unless by good fortune the
         * requested tlist is exactly the one the child wants to produce.
         */
        subplan = create_plan_recurse(root, best_path->subpath, 0);
        tlist = build_path_tlist(root, &best_path->path);
        needs_result_node = !tlist_same_exprs(tlist, subplan->targetlist);
    }
 
    /*
     * If we make a different decision about whether to include a Result node
     * than create_projection_path did, we'll have made slightly wrong cost
     * estimates; but label the plan with the cost estimates we actually used,
     * not "corrected" ones.  (XXX this could be cleaned up if we moved more
     * of the sortcolumn setup logic into Path creation, but that would add
     * expense to creating Paths we might end up not using.)
     */
    if (!needs_result_node)
    {
        /* Don't need a separate Result, just assign tlist to subplan */
        plan = subplan;
        plan->targetlist = tlist;
 
        /* Label plan with the estimated costs we actually used */
        plan->startup_cost = best_path->path.startup_cost;
        plan->total_cost = best_path->path.total_cost;
        plan->plan_rows = best_path->path.rows;
        plan->plan_width = best_path->path.pathtarget->width;
        plan->parallel_safe = best_path->path.parallel_safe;
        /* ... but don't change subplan's parallel_aware flag */
    }
    else
    {
        /* We need a Result node */
        plan = (Plan *) make_result(tlist, NULL, subplan);
 
        copy_generic_path_info(plan, (Path *) best_path);
    }
 
    return plan;
}

References apply_pathtarget_labeling_to_tlist(), Assert(), build_path_tlist(), copy_generic_path_info(), CP_IGNORE_TLIST, CP_LABEL_TLIST, create_plan_recurse(), is_projection_capable_path(), is_projection_capable_plan(), make_result(), Path::parallel_safe, ProjectionPath::path, plan, Path::rows, Path::startup_cost, ProjectionPath::subpath, Plan::targetlist, tlist_same_exprs(), Path::total_cost, and use_physical_tlist().

Referenced by create_plan_recurse().

create_recursiveunion_plan()

static RecursiveUnion * create_recursiveunion_plan ( PlannerInfo *  root, RecursiveUnionPath *  best_path  )

static

Definition at line 2753 of file createplan.c.

{
    RecursiveUnion *plan;
    Plan       *leftplan;
    Plan       *rightplan;
    List       *tlist;
    long        numGroups;
 
    /* Need both children to produce same tlist, so force it */
    leftplan = create_plan_recurse(root, best_path->leftpath, CP_EXACT_TLIST);
    rightplan = create_plan_recurse(root, best_path->rightpath, CP_EXACT_TLIST);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    /* Convert numGroups to long int --- but 'ware overflow! */
    numGroups = clamp_cardinality_to_long(best_path->numGroups);
 
    plan = make_recursive_union(tlist,
                                leftplan,
                                rightplan,
                                best_path->wtParam,
                                best_path->distinctList,
                                numGroups);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References build_path_tlist(), clamp_cardinality_to_long(), copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), RecursiveUnionPath::distinctList, RecursiveUnionPath::leftpath, make_recursive_union(), RecursiveUnionPath::numGroups, RecursiveUnionPath::path, plan, RecursiveUnionPath::rightpath, and RecursiveUnionPath::wtParam.

Referenced by create_plan_recurse().

create_resultscan_plan()

static Result * create_resultscan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 4012 of file createplan.c.

{
    Result     *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte PG_USED_FOR_ASSERTS_ONLY;
 
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_RESULT);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_result(tlist, (Node *) scan_clauses, NULL);
 
    copy_generic_path_info(&scan_plan->plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), extract_actual_clauses(), make_result(), order_qual_clauses(), PG_USED_FOR_ASSERTS_ONLY, Result::plan, planner_rt_fetch, replace_nestloop_params(), and RTE_RESULT.

Referenced by create_scan_plan().

create_samplescan_plan()

static SampleScan * create_samplescan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 2951 of file createplan.c.

{
    SampleScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    TableSampleClause *tsc;
 
    /* it should be a base rel with a tablesample clause... */
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_RELATION);
    tsc = rte->tablesample;
    Assert(tsc != NULL);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
        tsc = (TableSampleClause *)
            replace_nestloop_params(root, (Node *) tsc);
    }
 
    scan_plan = make_samplescan(tlist,
                                scan_clauses,
                                scan_relid,
                                tsc);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), extract_actual_clauses(), make_samplescan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), RTE_RELATION, RangeTblEntry::rtekind, SampleScan::scan, and RangeTblEntry::tablesample.

Referenced by create_scan_plan().

create_scan_plan()

static Plan * create_scan_plan ( PlannerInfo *  root, Path *  best_path, int  flags  )

static

Definition at line 557 of file createplan.c.

{
    RelOptInfo *rel = best_path->parent;
    List       *scan_clauses;
    List       *gating_clauses;
    List       *tlist;
    Plan       *plan;
 
    /*
     * Extract the relevant restriction clauses from the parent relation. The
     * executor must apply all these restrictions during the scan, except for
     * pseudoconstants which we'll take care of below.
     *
     * If this is a plain indexscan or index-only scan, we need not consider
     * restriction clauses that are implied by the index's predicate, so use
     * indrestrictinfo not baserestrictinfo.  Note that we can't do that for
     * bitmap indexscans, since there's not necessarily a single index
     * involved; but it doesn't matter since create_bitmap_scan_plan() will be
     * able to get rid of such clauses anyway via predicate proof.
     */
    switch (best_path->pathtype)
    {
        case T_IndexScan:
        case T_IndexOnlyScan:
            scan_clauses = castNode(IndexPath, best_path)->indexinfo->indrestrictinfo;
            break;
        default:
            scan_clauses = rel->baserestrictinfo;
            break;
    }
 
    /*
     * If this is a parameterized scan, we also need to enforce all the join
     * clauses available from the outer relation(s).
     *
     * For paranoia's sake, don't modify the stored baserestrictinfo list.
     */
    if (best_path->param_info)
        scan_clauses = list_concat_copy(scan_clauses,
                                        best_path->param_info->ppi_clauses);
 
    /*
     * Detect whether we have any pseudoconstant quals to deal with.  Then, if
     * we'll need a gating Result node, it will be able to project, so there
     * are no requirements on the child's tlist.
     *
     * If this replaces a join, it must be a foreign scan or a custom scan,
     * and the FDW or the custom scan provider would have stored in the best
     * path the list of RestrictInfo nodes to apply to the join; check against
     * that list in that case.
     */
    if (IS_JOIN_REL(rel))
    {
        List       *join_clauses;
 
        Assert(best_path->pathtype == T_ForeignScan ||
               best_path->pathtype == T_CustomScan);
        if (best_path->pathtype == T_ForeignScan)
            join_clauses = ((ForeignPath *) best_path)->fdw_restrictinfo;
        else
            join_clauses = ((CustomPath *) best_path)->custom_restrictinfo;
 
        gating_clauses = get_gating_quals(root, join_clauses);
    }
    else
        gating_clauses = get_gating_quals(root, scan_clauses);
    if (gating_clauses)
        flags = 0;
 
    /*
     * For table scans, rather than using the relation targetlist (which is
     * only those Vars actually needed by the query), we prefer to generate a
     * tlist containing all Vars in order.  This will allow the executor to
     * optimize away projection of the table tuples, if possible.
     *
     * But if the caller is going to ignore our tlist anyway, then don't
     * bother generating one at all.  We use an exact equality test here, so
     * that this only applies when CP_IGNORE_TLIST is the only flag set.
     */
    if (flags == CP_IGNORE_TLIST)
    {
        tlist = NULL;
    }
    else if (use_physical_tlist(root, best_path, flags))
    {
        if (best_path->pathtype == T_IndexOnlyScan)
        {
            /* For index-only scan, the preferred tlist is the index's */
            tlist = copyObject(((IndexPath *) best_path)->indexinfo->indextlist);
 
            /*
             * Transfer sortgroupref data to the replacement tlist, if
             * requested (use_physical_tlist checked that this will work).
             */
            if (flags & CP_LABEL_TLIST)
                apply_pathtarget_labeling_to_tlist(tlist, best_path->pathtarget);
        }
        else
        {
            tlist = build_physical_tlist(root, rel);
            if (tlist == NIL)
            {
                /* Failed because of dropped cols, so use regular method */
                tlist = build_path_tlist(root, best_path);
            }
            else
            {
                /* As above, transfer sortgroupref data to replacement tlist */
                if (flags & CP_LABEL_TLIST)
                    apply_pathtarget_labeling_to_tlist(tlist, best_path->pathtarget);
            }
        }
    }
    else
    {
        tlist = build_path_tlist(root, best_path);
    }
 
    switch (best_path->pathtype)
    {
        case T_SeqScan:
            plan = (Plan *) create_seqscan_plan(root,
                                                best_path,
                                                tlist,
                                                scan_clauses);
            break;
 
        case T_SampleScan:
            plan = (Plan *) create_samplescan_plan(root,
                                                   best_path,
                                                   tlist,
                                                   scan_clauses);
            break;
 
        case T_IndexScan:
            plan = (Plan *) create_indexscan_plan(root,
                                                  (IndexPath *) best_path,
                                                  tlist,
                                                  scan_clauses,
                                                  false);
            break;
 
        case T_IndexOnlyScan:
            plan = (Plan *) create_indexscan_plan(root,
                                                  (IndexPath *) best_path,
                                                  tlist,
                                                  scan_clauses,
                                                  true);
            break;
 
        case T_BitmapHeapScan:
            plan = (Plan *) create_bitmap_scan_plan(root,
                                                    (BitmapHeapPath *) best_path,
                                                    tlist,
                                                    scan_clauses);
            break;
 
        case T_TidScan:
            plan = (Plan *) create_tidscan_plan(root,
                                                (TidPath *) best_path,
                                                tlist,
                                                scan_clauses);
            break;
 
        case T_TidRangeScan:
            plan = (Plan *) create_tidrangescan_plan(root,
                                                     (TidRangePath *) best_path,
                                                     tlist,
                                                     scan_clauses);
            break;
 
        case T_SubqueryScan:
            plan = (Plan *) create_subqueryscan_plan(root,
                                                     (SubqueryScanPath *) best_path,
                                                     tlist,
                                                     scan_clauses);
            break;
 
        case T_FunctionScan:
            plan = (Plan *) create_functionscan_plan(root,
                                                     best_path,
                                                     tlist,
                                                     scan_clauses);
            break;
 
        case T_TableFuncScan:
            plan = (Plan *) create_tablefuncscan_plan(root,
                                                      best_path,
                                                      tlist,
                                                      scan_clauses);
            break;
 
        case T_ValuesScan:
            plan = (Plan *) create_valuesscan_plan(root,
                                                   best_path,
                                                   tlist,
                                                   scan_clauses);
            break;
 
        case T_CteScan:
            plan = (Plan *) create_ctescan_plan(root,
                                                best_path,
                                                tlist,
                                                scan_clauses);
            break;
 
        case T_NamedTuplestoreScan:
            plan = (Plan *) create_namedtuplestorescan_plan(root,
                                                            best_path,
                                                            tlist,
                                                            scan_clauses);
            break;
 
        case T_Result:
            plan = (Plan *) create_resultscan_plan(root,
                                                   best_path,
                                                   tlist,
                                                   scan_clauses);
            break;
 
        case T_WorkTableScan:
            plan = (Plan *) create_worktablescan_plan(root,
                                                      best_path,
                                                      tlist,
                                                      scan_clauses);
            break;
 
        case T_ForeignScan:
            plan = (Plan *) create_foreignscan_plan(root,
                                                    (ForeignPath *) best_path,
                                                    tlist,
                                                    scan_clauses);
            break;
 
        case T_CustomScan:
            plan = (Plan *) create_customscan_plan(root,
                                                   (CustomPath *) best_path,
                                                   tlist,
                                                   scan_clauses);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) best_path->pathtype);
            plan = NULL;        /* keep compiler quiet */
            break;
    }
 
    /*
     * If there are any pseudoconstant clauses attached to this node, insert a
     * gating Result node that evaluates the pseudoconstants as one-time
     * quals.
     */
    if (gating_clauses)
        plan = create_gating_plan(root, best_path, plan, gating_clauses);
 
    return plan;
}

References apply_pathtarget_labeling_to_tlist(), Assert(), RelOptInfo::baserestrictinfo, build_path_tlist(), build_physical_tlist(), castNode, copyObject, CP_IGNORE_TLIST, CP_LABEL_TLIST, create_bitmap_scan_plan(), create_ctescan_plan(), create_customscan_plan(), create_foreignscan_plan(), create_functionscan_plan(), create_gating_plan(), create_indexscan_plan(), create_namedtuplestorescan_plan(), create_resultscan_plan(), create_samplescan_plan(), create_seqscan_plan(), create_subqueryscan_plan(), create_tablefuncscan_plan(), create_tidrangescan_plan(), create_tidscan_plan(), create_valuesscan_plan(), create_worktablescan_plan(), elog(), ERROR, get_gating_quals(), IS_JOIN_REL, list_concat_copy(), NIL, Path::pathtype, plan, and use_physical_tlist().

Referenced by create_plan_recurse().

create_seqscan_plan()

static SeqScan * create_seqscan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 2913 of file createplan.c.

{
    SeqScan    *scan_plan;
    Index       scan_relid = best_path->parent->relid;
 
    /* it should be a base rel... */
    Assert(scan_relid > 0);
    Assert(best_path->parent->rtekind == RTE_RELATION);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_seqscan(tlist,
                             scan_clauses,
                             scan_relid);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), extract_actual_clauses(), make_seqscan(), order_qual_clauses(), replace_nestloop_params(), RTE_RELATION, and SeqScan::scan.

Referenced by create_scan_plan().

create_setop_plan()

static SetOp * create_setop_plan ( PlannerInfo *  root, SetOpPath *  best_path, int  flags  )

static

Definition at line 2717 of file createplan.c.

{
    SetOp      *plan;
    Plan       *subplan;
    long        numGroups;
 
    /*
     * SetOp doesn't project, so tlist requirements pass through; moreover we
     * need grouping columns to be labeled.
     */
    subplan = create_plan_recurse(root, best_path->subpath,
                                  flags | CP_LABEL_TLIST);
 
    /* Convert numGroups to long int --- but 'ware overflow! */
    numGroups = clamp_cardinality_to_long(best_path->numGroups);
 
    plan = make_setop(best_path->cmd,
                      best_path->strategy,
                      subplan,
                      best_path->distinctList,
                      best_path->flagColIdx,
                      best_path->firstFlag,
                      numGroups);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References clamp_cardinality_to_long(), SetOpPath::cmd, copy_generic_path_info(), CP_LABEL_TLIST, create_plan_recurse(), SetOpPath::distinctList, SetOpPath::firstFlag, SetOpPath::flagColIdx, make_setop(), SetOpPath::numGroups, plan, SetOpPath::strategy, and SetOpPath::subpath.

Referenced by create_plan_recurse().

create_sort_plan()

static Sort * create_sort_plan ( PlannerInfo *  root, SortPath *  best_path, int  flags  )

static

Definition at line 2178 of file createplan.c.

{
    Sort       *plan;
    Plan       *subplan;
 
    /*
     * We don't want any excess columns in the sorted tuples, so request a
     * smaller tlist.  Otherwise, since Sort doesn't project, tlist
     * requirements pass through.
     */
    subplan = create_plan_recurse(root, best_path->subpath,
                                  flags | CP_SMALL_TLIST);
 
    /*
     * make_sort_from_pathkeys indirectly calls find_ec_member_matching_expr,
     * which will ignore any child EC members that don't belong to the given
     * relids. Thus, if this sort path is based on a child relation, we must
     * pass its relids.
     */
    plan = make_sort_from_pathkeys(subplan, best_path->path.pathkeys,
                                   IS_OTHER_REL(best_path->subpath->parent) ?
                                   best_path->path.parent->relids : NULL);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), CP_SMALL_TLIST, create_plan_recurse(), IS_OTHER_REL, make_sort_from_pathkeys(), SortPath::path, Path::pathkeys, plan, and SortPath::subpath.

Referenced by create_plan_recurse().

create_subqueryscan_plan()

static SubqueryScan * create_subqueryscan_plan ( PlannerInfo *  root, SubqueryScanPath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3698 of file createplan.c.

{
    SubqueryScan *scan_plan;
    RelOptInfo *rel = best_path->path.parent;
    Index       scan_relid = rel->relid;
    Plan       *subplan;
 
    /* it should be a subquery base rel... */
    Assert(scan_relid > 0);
    Assert(rel->rtekind == RTE_SUBQUERY);
 
    /*
     * Recursively create Plan from Path for subquery.  Since we are entering
     * a different planner context (subroot), recurse to create_plan not
     * create_plan_recurse.
     */
    subplan = create_plan(rel->subroot, best_path->subpath);
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->path.param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
        process_subquery_nestloop_params(root,
                                         rel->subplan_params);
    }
 
    scan_plan = make_subqueryscan(tlist,
                                  scan_clauses,
                                  scan_relid,
                                  subplan);
 
    copy_generic_path_info(&scan_plan->scan.plan, &best_path->path);
 
    return scan_plan;
}

References Assert(), copy_generic_path_info(), create_plan(), extract_actual_clauses(), make_subqueryscan(), order_qual_clauses(), SubqueryScanPath::path, process_subquery_nestloop_params(), RelOptInfo::relid, replace_nestloop_params(), RTE_SUBQUERY, RelOptInfo::rtekind, SubqueryScan::scan, SubqueryScanPath::subpath, RelOptInfo::subplan_params, and RelOptInfo::subroot.

Referenced by create_scan_plan().

create_tablefuncscan_plan()

static TableFuncScan * create_tablefuncscan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3791 of file createplan.c.

{
    TableFuncScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    TableFunc  *tablefunc;
 
    /* it should be a function base rel... */
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_TABLEFUNC);
    tablefunc = rte->tablefunc;
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->param_info)
    {
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
        /* The function expressions could contain nestloop params, too */
        tablefunc = (TableFunc *) replace_nestloop_params(root, (Node *) tablefunc);
    }
 
    scan_plan = make_tablefuncscan(tlist, scan_clauses, scan_relid,
                                   tablefunc);