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/pathnode.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, List *mergeJoinConditions, 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 69 of file createplan.c.

CP_IGNORE_TLIST

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

Definition at line 72 of file createplan.c.

CP_LABEL_TLIST

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

Definition at line 71 of file createplan.c.

CP_SMALL_TLIST

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

Definition at line 70 of file createplan.c.

Function Documentation

bitmap_subplan_mark_shared()

static void bitmap_subplan_mark_shared ( Plan *  plan )

static

Definition at line 5473 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 825 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(), TargetEntry::ressortgroupref, and root.

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 2147 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 5404 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 5419 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 2303 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, root, 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 1216 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(), root, 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 3196 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(), root, 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 3326 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, root, 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 3885 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(), root, RTE_CTE, RangeTblEntry::rtekind, CteScan::scan, 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 4271 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(), root, 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 4116 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 Assert, RelOptInfo::baserestrictinfo, bms_difference(), bms_free(), bms_is_member(), ForeignScan::checkAsUser, RestrictInfo::clause, copy_generic_path_info(), CP_EXACT_TLIST, create_plan_recurse(), 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, i, InvalidOid, lfirst, order_qual_clauses(), ForeignPath::path, planner_rt_fetch, pull_varattnos(), RangeTblEntry::relid, RelOptInfo::relid, RELOPT_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, replace_nestloop_params(), root, 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 3755 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(), root, 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 1957 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.  See create_gather_merge_path.
     */
    Assert(pathkeys_contained_in(pathkeys, best_path->subpath->pathkeys));
 
    /* 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(), Plan::lefttree, makeNode, NIL, GatherMergePath::num_workers, GatherMerge::num_workers, GatherMerge::numCols, GatherMergePath::path, Path::pathkeys, pathkeys_contained_in(), GatherMerge::plan, prepare_sort_from_pathkeys(), GatherMerge::rescan_param, root, 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 1919 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(), make_gather(), NIL, GatherPath::num_workers, GatherPath::path, Gather::plan, root, 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 1022 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, root, 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 2236 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, root, 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 1587 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, GroupResultPath::quals, and root.

Referenced by create_plan_recurse().

create_groupingsets_plan()

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

static

Definition at line 2387 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, RollupData::gsets, RollupData::is_hashed, lappend(), Plan::lefttree, lfirst, linitial, list_length(), make_agg(), make_sort_from_groupcols(), NIL, RollupData::numGroups, palloc0(), GroupingSetsPath::path, plan, GroupingSetsPath::qual, remap_groupColIdx(), TargetEntry::resno, GroupingSetsPath::rollups, root, 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 4741 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(), root, 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 2209 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, root, 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 3000 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(), root, 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 1081 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, plan, and root.

Referenced by create_plan_recurse().

create_limit_plan()

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

static

Definition at line 2850 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(), plan, TargetEntry::resno, root, 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 2786 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, root, 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 1638 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, root, 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 1666 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(), root, 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 1437 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, root, 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 4434 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(), root, 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 2545 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(), MinMaxAggPath::mmaggregates, NIL, Path::parallel_safe, MinMaxAggInfo::param, PlannerInfo::parse, MinMaxAggPath::path, MinMaxAggInfo::path, MinMaxAggInfo::pathcost, plan, MinMaxAggPath::quals, root, 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 2809 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->mergeJoinConditions,
                            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::mergeJoinConditions, ModifyTablePath::nominalRelation, ModifyTablePath::onconflict, ModifyTablePath::operation, ModifyTablePath::partColsUpdated, ModifyTablePath::path, plan, ModifyTablePath::resultRelations, ModifyTablePath::returningLists, root, 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 3980 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(), root, 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 4342 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;
 
    /*
     * If the inner path is parameterized by the topmost parent of the outer
     * rel rather than the outer rel itself, fix that.  (Nothing happens here
     * if it is not so parameterized.)
     */
    best_path->jpath.innerjoinpath =
        reparameterize_path_by_child(root,
                                     best_path->jpath.innerjoinpath,
                                     best_path->jpath.outerjoinpath->parent);
 
    /*
     * Failure here probably means that reparameterize_path_by_child() is not
     * in sync with path_is_reparameterizable_by_child().
     */
    Assert(best_path->jpath.innerjoinpath != NULL);
 
    /* 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 Assert, bms_free(), bms_union(), build_path_tlist(), copy_generic_path_info(), create_plan_recurse(), 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, reparameterize_path_by_child(), replace_nestloop_params(), and root.

Referenced by create_join_plan().

create_plan()

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

Definition at line 337 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(), elog, ERROR, IsA, NIL, plan, root, 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 388 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, plan, and root.

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 1612 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, root, 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 2013 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, root, 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 2750 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, root, 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 4019 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(), root, 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 2949 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(), root, 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 559 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, root, 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 2911 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(), root, 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 2714 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, root, 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 2175 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, root, 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 3696 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.
     *
     * We must provide nestloop params for both lateral references of the
     * subquery and outer vars in the scan_clauses.  It's better to assign the
     * former first, because that code path requires specific param IDs, while
     * replace_nestloop_params can adapt to the IDs assigned by
     * process_subquery_nestloop_params.  This avoids possibly duplicating
     * nestloop params when the same Var is needed for both reasons.
     */
    if (best_path->path.param_info)
    {
        process_subquery_nestloop_params(root,
                                         rel->subplan_params);
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    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(), root, 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 3798 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);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert, copy_generic_path_info(), extract_actual_clauses(), make_tablefuncscan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), root, RTE_TABLEFUNC, RangeTblEntry::rtekind, TableFuncScan::scan, and RangeTblEntry::tablefunc.

Referenced by create_scan_plan().

create_tidrangescan_plan()

static TidRangeScan * create_tidrangescan_plan ( PlannerInfo *  root, TidRangePath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3631 of file createplan.c.

{
    TidRangeScan *scan_plan;
    Index       scan_relid = best_path->path.parent->relid;
    List       *tidrangequals = best_path->tidrangequals;
 
    /* it should be a base rel... */
    Assert(scan_relid > 0);
    Assert(best_path->path.parent->rtekind == RTE_RELATION);
 
    /*
     * The qpqual list must contain all restrictions not enforced by the
     * tidrangequals list.  tidrangequals has AND semantics, so we can simply
     * remove any qual that appears in it.
     */
    {
        List       *qpqual = NIL;
        ListCell   *l;
 
        foreach(l, scan_clauses)
        {
            RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
 
            if (rinfo->pseudoconstant)
                continue;       /* we may drop pseudoconstants here */
            if (list_member_ptr(tidrangequals, rinfo))
                continue;       /* simple duplicate */
            qpqual = lappend(qpqual, rinfo);
        }
        scan_clauses = qpqual;
    }
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo lists to bare expressions; ignore pseudoconstants */
    tidrangequals = extract_actual_clauses(tidrangequals, false);
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->path.param_info)
    {
        tidrangequals = (List *)
            replace_nestloop_params(root, (Node *) tidrangequals);
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_tidrangescan(tlist,
                                  scan_clauses,
                                  scan_relid,
                                  tidrangequals);
 
    copy_generic_path_info(&scan_plan->scan.plan, &best_path->path);
 
    return scan_plan;
}

References Assert, copy_generic_path_info(), extract_actual_clauses(), lappend(), lfirst_node, list_member_ptr(), make_tidrangescan(), NIL, order_qual_clauses(), TidRangePath::path, replace_nestloop_params(), root, RTE_RELATION, TidRangeScan::scan, and TidRangePath::tidrangequals.

Referenced by create_scan_plan().

create_tidscan_plan()

static TidScan * create_tidscan_plan ( PlannerInfo *  root, TidPath *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3534 of file createplan.c.

{
    TidScan    *scan_plan;
    Index       scan_relid = best_path->path.parent->relid;
    List       *tidquals = best_path->tidquals;
 
    /* it should be a base rel... */
    Assert(scan_relid > 0);
    Assert(best_path->path.parent->rtekind == RTE_RELATION);
 
    /*
     * The qpqual list must contain all restrictions not enforced by the
     * tidquals list.  Since tidquals has OR semantics, we have to be careful
     * about matching it up to scan_clauses.  It's convenient to handle the
     * single-tidqual case separately from the multiple-tidqual case.  In the
     * single-tidqual case, we look through the scan_clauses while they are
     * still in RestrictInfo form, and drop any that are redundant with the
     * tidqual.
     *
     * In normal cases simple pointer equality checks will be enough to spot
     * duplicate RestrictInfos, so we try that first.
     *
     * Another common case is that a scan_clauses entry is generated from the
     * same EquivalenceClass as some tidqual, and is therefore redundant with
     * it, though not equal.
     *
     * Unlike indexpaths, we don't bother with predicate_implied_by(); the
     * number of cases where it could win are pretty small.
     */
    if (list_length(tidquals) == 1)
    {
        List       *qpqual = NIL;
        ListCell   *l;
 
        foreach(l, scan_clauses)
        {
            RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
 
            if (rinfo->pseudoconstant)
                continue;       /* we may drop pseudoconstants here */
            if (list_member_ptr(tidquals, rinfo))
                continue;       /* simple duplicate */
            if (is_redundant_derived_clause(rinfo, tidquals))
                continue;       /* derived from same EquivalenceClass */
            qpqual = lappend(qpqual, rinfo);
        }
        scan_clauses = qpqual;
    }
 
    /* Sort clauses into best execution order */
    scan_clauses = order_qual_clauses(root, scan_clauses);
 
    /* Reduce RestrictInfo lists to bare expressions; ignore pseudoconstants */
    tidquals = extract_actual_clauses(tidquals, false);
    scan_clauses = extract_actual_clauses(scan_clauses, false);
 
    /*
     * If we have multiple tidquals, it's more convenient to remove duplicate
     * scan_clauses after stripping the RestrictInfos.  In this situation,
     * because the tidquals represent OR sub-clauses, they could not have come
     * from EquivalenceClasses so we don't have to worry about matching up
     * non-identical clauses.  On the other hand, because tidpath.c will have
     * extracted those sub-clauses from some OR clause and built its own list,
     * we will certainly not have pointer equality to any scan clause.  So
     * convert the tidquals list to an explicit OR clause and see if we can
     * match it via equal() to any scan clause.
     */
    if (list_length(tidquals) > 1)
        scan_clauses = list_difference(scan_clauses,
                                       list_make1(make_orclause(tidquals)));
 
    /* Replace any outer-relation variables with nestloop params */
    if (best_path->path.param_info)
    {
        tidquals = (List *)
            replace_nestloop_params(root, (Node *) tidquals);
        scan_clauses = (List *)
            replace_nestloop_params(root, (Node *) scan_clauses);
    }
 
    scan_plan = make_tidscan(tlist,
                             scan_clauses,
                             scan_relid,
                             tidquals);
 
    copy_generic_path_info(&scan_plan->scan.plan, &best_path->path);
 
    return scan_plan;
}

References Assert, copy_generic_path_info(), extract_actual_clauses(), is_redundant_derived_clause(), lappend(), lfirst_node, list_difference(), list_length(), list_make1, list_member_ptr(), make_orclause(), make_tidscan(), NIL, order_qual_clauses(), TidPath::path, replace_nestloop_params(), root, RTE_RELATION, TidScan::scan, and TidPath::tidquals.

Referenced by create_scan_plan().

create_unique_plan()

static Plan * create_unique_plan ( PlannerInfo *  root, UniquePath *  best_path, int  flags  )

static

Definition at line 1720 of file createplan.c.

{
    Plan       *plan;
    Plan       *subplan;
    List       *in_operators;
    List       *uniq_exprs;
    List       *newtlist;
    int         nextresno;
    bool        newitems;
    int         numGroupCols;
    AttrNumber *groupColIdx;
    Oid        *groupCollations;
    int         groupColPos;
    ListCell   *l;
 
    /* Unique doesn't project, so tlist requirements pass through */
    subplan = create_plan_recurse(root, best_path->subpath, flags);
 
    /* Done if we don't need to do any actual unique-ifying */
    if (best_path->umethod == UNIQUE_PATH_NOOP)
        return subplan;
 
    /*
     * As constructed, the subplan has a "flat" tlist containing just the Vars
     * needed here and at upper levels.  The values we are supposed to
     * unique-ify may be expressions in these variables.  We have to add any
     * such expressions to the subplan's tlist.
     *
     * The subplan may have a "physical" tlist if it is a simple scan plan. If
     * we're going to sort, this should be reduced to the regular tlist, so
     * that we don't sort more data than we need to.  For hashing, the tlist
     * should be left as-is if we don't need to add any expressions; but if we
     * do have to add expressions, then a projection step will be needed at
     * runtime anyway, so we may as well remove unneeded items. Therefore
     * newtlist starts from build_path_tlist() not just a copy of the
     * subplan's tlist; and we don't install it into the subplan unless we are
     * sorting or stuff has to be added.
     */
    in_operators = best_path->in_operators;
    uniq_exprs = best_path->uniq_exprs;
 
    /* initialize modified subplan tlist as just the "required" vars */
    newtlist = build_path_tlist(root, &best_path->path);
    nextresno = list_length(newtlist) + 1;
    newitems = false;
 
    foreach(l, uniq_exprs)
    {
        Expr       *uniqexpr = lfirst(l);
        TargetEntry *tle;
 
        tle = tlist_member(uniqexpr, newtlist);
        if (!tle)
        {
            tle = makeTargetEntry((Expr *) uniqexpr,
                                  nextresno,
                                  NULL,
                                  false);
            newtlist = lappend(newtlist, tle);
            nextresno++;
            newitems = true;
        }
    }
 
    /* Use change_plan_targetlist in case we need to insert a Result node */
    if (newitems || best_path->umethod == UNIQUE_PATH_SORT)
        subplan = change_plan_targetlist(subplan, newtlist,
                                         best_path->path.parallel_safe);
 
    /*
     * Build control information showing which subplan output columns are to
     * be examined by the grouping step.  Unfortunately we can't merge this
     * with the previous loop, since we didn't then know which version of the
     * subplan tlist we'd end up using.
     */
    newtlist = subplan->targetlist;
    numGroupCols = list_length(uniq_exprs);
    groupColIdx = (AttrNumber *) palloc(numGroupCols * sizeof(AttrNumber));
    groupCollations = (Oid *) palloc(numGroupCols * sizeof(Oid));
 
    groupColPos = 0;
    foreach(l, uniq_exprs)
    {
        Expr       *uniqexpr = lfirst(l);
        TargetEntry *tle;
 
        tle = tlist_member(uniqexpr, newtlist);
        if (!tle)               /* shouldn't happen */
            elog(ERROR, "failed to find unique expression in subplan tlist");
        groupColIdx[groupColPos] = tle->resno;
        groupCollations[groupColPos] = exprCollation((Node *) tle->expr);
        groupColPos++;
    }
 
    if (best_path->umethod == UNIQUE_PATH_HASH)
    {
        Oid        *groupOperators;
 
        /*
         * Get the hashable equality operators for the Agg node to use.
         * Normally these are the same as the IN clause operators, but if
         * those are cross-type operators then the equality operators are the
         * ones for the IN clause operators' RHS datatype.
         */
        groupOperators = (Oid *) palloc(numGroupCols * sizeof(Oid));
        groupColPos = 0;
        foreach(l, in_operators)
        {
            Oid         in_oper = lfirst_oid(l);
            Oid         eq_oper;
 
            if (!get_compatible_hash_operators(in_oper, NULL, &eq_oper))
                elog(ERROR, "could not find compatible hash operator for operator %u",
                     in_oper);
            groupOperators[groupColPos++] = eq_oper;
        }
 
        /*
         * Since the Agg node is going to project anyway, we can give it the
         * minimum output tlist, without any stuff we might have added to the
         * subplan tlist.
         */
        plan = (Plan *) make_agg(build_path_tlist(root, &best_path->path),
                                 NIL,
                                 AGG_HASHED,
                                 AGGSPLIT_SIMPLE,
                                 numGroupCols,
                                 groupColIdx,
                                 groupOperators,
                                 groupCollations,
                                 NIL,
                                 NIL,
                                 best_path->path.rows,
                                 0,
                                 subplan);
    }
    else
    {
        List       *sortList = NIL;
        Sort       *sort;
 
        /* Create an ORDER BY list to sort the input compatibly */
        groupColPos = 0;
        foreach(l, in_operators)
        {
            Oid         in_oper = lfirst_oid(l);
            Oid         sortop;
            Oid         eqop;
            TargetEntry *tle;
            SortGroupClause *sortcl;
 
            sortop = get_ordering_op_for_equality_op(in_oper, false);
            if (!OidIsValid(sortop))    /* shouldn't happen */
                elog(ERROR, "could not find ordering operator for equality operator %u",
                     in_oper);
 
            /*
             * The Unique node will need equality operators.  Normally these
             * are the same as the IN clause operators, but if those are
             * cross-type operators then the equality operators are the ones
             * for the IN clause operators' RHS datatype.
             */
            eqop = get_equality_op_for_ordering_op(sortop, NULL);
            if (!OidIsValid(eqop))  /* shouldn't happen */
                elog(ERROR, "could not find equality operator for ordering operator %u",
                     sortop);
 
            tle = get_tle_by_resno(subplan->targetlist,
                                   groupColIdx[groupColPos]);
            Assert(tle != NULL);
 
            sortcl = makeNode(SortGroupClause);
            sortcl->tleSortGroupRef = assignSortGroupRef(tle,
                                                         subplan->targetlist);
            sortcl->eqop = eqop;
            sortcl->sortop = sortop;
            sortcl->nulls_first = false;
            sortcl->hashable = false;   /* no need to make this accurate */
            sortList = lappend(sortList, sortcl);
            groupColPos++;
        }
        sort = make_sort_from_sortclauses(sortList, subplan);
        label_sort_with_costsize(root, sort, -1.0);
        plan = (Plan *) make_unique_from_sortclauses((Plan *) sort, sortList);
    }
 
    /* Copy cost data from Path to Plan */
    copy_generic_path_info(plan, &best_path->path);
 
    return plan;
}

References AGG_HASHED, AGGSPLIT_SIMPLE, Assert, assignSortGroupRef(), build_path_tlist(), change_plan_targetlist(), copy_generic_path_info(), create_plan_recurse(), elog, SortGroupClause::eqop, ERROR, TargetEntry::expr, exprCollation(), get_compatible_hash_operators(), get_equality_op_for_ordering_op(), get_ordering_op_for_equality_op(), get_tle_by_resno(), UniquePath::in_operators, label_sort_with_costsize(), lappend(), lfirst, lfirst_oid, list_length(), make_agg(), make_sort_from_sortclauses(), make_unique_from_sortclauses(), makeNode, makeTargetEntry(), NIL, SortGroupClause::nulls_first, OidIsValid, palloc(), Path::parallel_safe, UniquePath::path, plan, TargetEntry::resno, root, Path::rows, sort(), SortGroupClause::sortop, UniquePath::subpath, Plan::targetlist, SortGroupClause::tleSortGroupRef, tlist_member(), UniquePath::umethod, UniquePath::uniq_exprs, UNIQUE_PATH_HASH, UNIQUE_PATH_NOOP, and UNIQUE_PATH_SORT.

Referenced by create_plan_recurse().

create_upper_unique_plan()

static Unique * create_upper_unique_plan ( PlannerInfo *  root, UpperUniquePath *  best_path, int  flags  )

static

Definition at line 2275 of file createplan.c.

{
    Unique     *plan;
    Plan       *subplan;
 
    /*
     * Unique 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);
 
    plan = make_unique_from_pathkeys(subplan,
                                     best_path->path.pathkeys,
                                     best_path->numkeys);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References copy_generic_path_info(), CP_LABEL_TLIST, create_plan_recurse(), make_unique_from_pathkeys(), UpperUniquePath::numkeys, UpperUniquePath::path, Path::pathkeys, plan, root, and UpperUniquePath::subpath.

Referenced by create_plan_recurse().

create_valuesscan_plan()

static ValuesScan * create_valuesscan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 3841 of file createplan.c.

{
    ValuesScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    List       *values_lists;
 
    /* it should be a values base rel... */
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_VALUES);
    values_lists = rte->values_lists;
 
    /* 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 values lists could contain nestloop params, too */
        values_lists = (List *)
            replace_nestloop_params(root, (Node *) values_lists);
    }
 
    scan_plan = make_valuesscan(tlist, scan_clauses, scan_relid,
                                values_lists);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert, copy_generic_path_info(), extract_actual_clauses(), make_valuesscan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), root, RTE_VALUES, RangeTblEntry::rtekind, ValuesScan::scan, and RangeTblEntry::values_lists.

Referenced by create_scan_plan().

create_windowagg_plan()

static WindowAgg * create_windowagg_plan ( PlannerInfo *  root, WindowAggPath *  best_path  )

static

Definition at line 2611 of file createplan.c.

{
    WindowAgg  *plan;
    WindowClause *wc = best_path->winclause;
    int         numPart = list_length(wc->partitionClause);
    int         numOrder = list_length(wc->orderClause);
    Plan       *subplan;
    List       *tlist;
    int         partNumCols;
    AttrNumber *partColIdx;
    Oid        *partOperators;
    Oid        *partCollations;
    int         ordNumCols;
    AttrNumber *ordColIdx;
    Oid        *ordOperators;
    Oid        *ordCollations;
    ListCell   *lc;
 
    /*
     * Choice of tlist here is motivated by the fact that WindowAgg will be
     * storing the input rows of window frames in a tuplestore; it therefore
     * behooves us to request a small tlist to avoid wasting space. We do of
     * course need grouping columns to be available.
     */
    subplan = create_plan_recurse(root, best_path->subpath,
                                  CP_LABEL_TLIST | CP_SMALL_TLIST);
 
    tlist = build_path_tlist(root, &best_path->path);
 
    /*
     * Convert SortGroupClause lists into arrays of attr indexes and equality
     * operators, as wanted by executor.
     */
    partColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numPart);
    partOperators = (Oid *) palloc(sizeof(Oid) * numPart);
    partCollations = (Oid *) palloc(sizeof(Oid) * numPart);
 
    partNumCols = 0;
    foreach(lc, wc->partitionClause)
    {
        SortGroupClause *sgc = (SortGroupClause *) lfirst(lc);
        TargetEntry *tle = get_sortgroupclause_tle(sgc, subplan->targetlist);
 
        Assert(OidIsValid(sgc->eqop));
        partColIdx[partNumCols] = tle->resno;
        partOperators[partNumCols] = sgc->eqop;
        partCollations[partNumCols] = exprCollation((Node *) tle->expr);
        partNumCols++;
    }
 
    ordColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numOrder);
    ordOperators = (Oid *) palloc(sizeof(Oid) * numOrder);
    ordCollations = (Oid *) palloc(sizeof(Oid) * numOrder);
 
    ordNumCols = 0;
    foreach(lc, wc->orderClause)
    {
        SortGroupClause *sgc = (SortGroupClause *) lfirst(lc);
        TargetEntry *tle = get_sortgroupclause_tle(sgc, subplan->targetlist);
 
        Assert(OidIsValid(sgc->eqop));
        ordColIdx[ordNumCols] = tle->resno;
        ordOperators[ordNumCols] = sgc->eqop;
        ordCollations[ordNumCols] = exprCollation((Node *) tle->expr);
        ordNumCols++;
    }
 
    /* And finally we can make the WindowAgg node */
    plan = make_windowagg(tlist,
                          wc->winref,
                          partNumCols,
                          partColIdx,
                          partOperators,
                          partCollations,
                          ordNumCols,
                          ordColIdx,
                          ordOperators,
                          ordCollations,
                          wc->frameOptions,
                          wc->startOffset,
                          wc->endOffset,
                          wc->startInRangeFunc,
                          wc->endInRangeFunc,
                          wc->inRangeColl,
                          wc->inRangeAsc,
                          wc->inRangeNullsFirst,
                          best_path->runCondition,
                          best_path->qual,
                          best_path->topwindow,
                          subplan);
 
    copy_generic_path_info(&plan->plan, (Path *) best_path);
 
    return plan;
}

References Assert, build_path_tlist(), copy_generic_path_info(), CP_LABEL_TLIST, CP_SMALL_TLIST, create_plan_recurse(), WindowClause::endOffset, SortGroupClause::eqop, TargetEntry::expr, exprCollation(), WindowClause::frameOptions, get_sortgroupclause_tle(), lfirst, list_length(), make_windowagg(), OidIsValid, WindowClause::orderClause, palloc(), WindowClause::partitionClause, WindowAggPath::path, plan, WindowAggPath::qual, TargetEntry::resno, root, WindowAggPath::runCondition, WindowClause::startOffset, WindowAggPath::subpath, Plan::targetlist, WindowAggPath::topwindow, WindowAggPath::winclause, and WindowClause::winref.

Referenced by create_plan_recurse().

create_worktablescan_plan()

static WorkTableScan * create_worktablescan_plan ( PlannerInfo *  root, Path *  best_path, List *  tlist, List *  scan_clauses  )

static

Definition at line 4056 of file createplan.c.

{
    WorkTableScan *scan_plan;
    Index       scan_relid = best_path->parent->relid;
    RangeTblEntry *rte;
    Index       levelsup;
    PlannerInfo *cteroot;
 
    Assert(scan_relid > 0);
    rte = planner_rt_fetch(scan_relid, root);
    Assert(rte->rtekind == RTE_CTE);
    Assert(rte->self_reference);
 
    /*
     * We need to find the worktable param ID, which is in the plan level
     * that's processing the recursive UNION, which is one level *below* where
     * the CTE comes from.
     */
    levelsup = rte->ctelevelsup;
    if (levelsup == 0)          /* shouldn't happen */
        elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    levelsup--;
    cteroot = root;
    while (levelsup-- > 0)
    {
        cteroot = cteroot->parent_root;
        if (!cteroot)           /* shouldn't happen */
            elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
    }
    if (cteroot->wt_param_id < 0)   /* shouldn't happen */
        elog(ERROR, "could not find param ID for CTE \"%s\"", rte->ctename);
 
    /* 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_worktablescan(tlist, scan_clauses, scan_relid,
                                   cteroot->wt_param_id);
 
    copy_generic_path_info(&scan_plan->scan.plan, best_path);
 
    return scan_plan;
}

References Assert, copy_generic_path_info(), RangeTblEntry::ctelevelsup, RangeTblEntry::ctename, elog, ERROR, extract_actual_clauses(), make_worktablescan(), order_qual_clauses(), planner_rt_fetch, replace_nestloop_params(), root, RTE_CTE, RangeTblEntry::rtekind, WorkTableScan::scan, and PlannerInfo::wt_param_id.

Referenced by create_scan_plan().

fix_indexorderby_references()

static List * fix_indexorderby_references ( PlannerInfo *  root, IndexPath *  index_path  )

static

Definition at line 5058 of file createplan.c.

{
    IndexOptInfo *index = index_path->indexinfo;
    List       *fixed_indexorderbys;
    ListCell   *lcc,
               *lci;
 
    fixed_indexorderbys = NIL;
 
    forboth(lcc, index_path->indexorderbys, lci, index_path->indexorderbycols)
    {
        Node       *clause = (Node *) lfirst(lcc);
        int         indexcol = lfirst_int(lci);
 
        clause = fix_indexqual_clause(root, index, indexcol, clause, NIL);
        fixed_indexorderbys = lappend(fixed_indexorderbys, clause);
    }
 
    return fixed_indexorderbys;
}

References fix_indexqual_clause(), forboth, IndexPath::indexinfo, IndexPath::indexorderbycols, IndexPath::indexorderbys, lappend(), lfirst, lfirst_int, NIL, and root.

Referenced by create_indexscan_plan().

fix_indexqual_clause()

static Node * fix_indexqual_clause ( PlannerInfo *  root, IndexOptInfo *  index, int  indexcol, Node *  clause, List *  indexcolnos  )

static

Definition at line 5087 of file createplan.c.

{
    /*
     * Replace any outer-relation variables with nestloop params.
     *
     * This also makes a copy of the clause, so it's safe to modify it
     * in-place below.
     */
    clause = replace_nestloop_params(root, clause);
 
    if (IsA(clause, OpExpr))
    {
        OpExpr     *op = (OpExpr *) clause;
 
        /* Replace the indexkey expression with an index Var. */
        linitial(op->args) = fix_indexqual_operand(linitial(op->args),
                                                   index,
                                                   indexcol);
    }
    else if (IsA(clause, RowCompareExpr))
    {
        RowCompareExpr *rc = (RowCompareExpr *) clause;
        ListCell   *lca,
                   *lcai;
 
        /* Replace the indexkey expressions with index Vars. */
        Assert(list_length(rc->largs) == list_length(indexcolnos));
        forboth(lca, rc->largs, lcai, indexcolnos)
        {
            lfirst(lca) = fix_indexqual_operand(lfirst(lca),
                                                index,
                                                lfirst_int(lcai));
        }
    }
    else if (IsA(clause, ScalarArrayOpExpr))
    {
        ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
 
        /* Replace the indexkey expression with an index Var. */
        linitial(saop->args) = fix_indexqual_operand(linitial(saop->args),
                                                     index,
                                                     indexcol);
    }
    else if (IsA(clause, NullTest))
    {
        NullTest   *nt = (NullTest *) clause;
 
        /* Replace the indexkey expression with an index Var. */
        nt->arg = (Expr *) fix_indexqual_operand((Node *) nt->arg,
                                                 index,
                                                 indexcol);
    }
    else
        elog(ERROR, "unsupported indexqual type: %d",
             (int) nodeTag(clause));
 
    return clause;
}

References NullTest::arg, OpExpr::args, ScalarArrayOpExpr::args, Assert, elog, ERROR, fix_indexqual_operand(), forboth, IsA, RowCompareExpr::largs, lca(), lfirst, lfirst_int, linitial, list_length(), nodeTag, replace_nestloop_params(), and root.

Referenced by fix_indexorderby_references(), and fix_indexqual_references().

fix_indexqual_operand()

static Node * fix_indexqual_operand ( Node *  node, IndexOptInfo *  index, int  indexcol  )

static

Definition at line 5158 of file createplan.c.

{
    Var        *result;
    int         pos;
    ListCell   *indexpr_item;
 
    /*
     * Remove any binary-compatible relabeling of the indexkey
     */
    if (IsA(node, RelabelType))
        node = (Node *) ((RelabelType *) node)->arg;
 
    Assert(indexcol >= 0 && indexcol < index->ncolumns);
 
    if (index->indexkeys[indexcol] != 0)
    {
        /* It's a simple index column */
        if (IsA(node, Var) &&
            ((Var *) node)->varno == index->rel->relid &&
            ((Var *) node)->varattno == index->indexkeys[indexcol])
        {
            result = (Var *) copyObject(node);
            result->varno = INDEX_VAR;
            result->varattno = indexcol + 1;
            return (Node *) result;
        }
        else
            elog(ERROR, "index key does not match expected index column");
    }
 
    /* It's an index expression, so find and cross-check the expression */
    indexpr_item = list_head(index->indexprs);
    for (pos = 0; pos < index->ncolumns; pos++)
    {
        if (index->indexkeys[pos] == 0)
        {
            if (indexpr_item == NULL)
                elog(ERROR, "too few entries in indexprs list");
            if (pos == indexcol)
            {
                Node       *indexkey;
 
                indexkey = (Node *) lfirst(indexpr_item);
                if (indexkey && IsA(indexkey, RelabelType))
                    indexkey = (Node *) ((RelabelType *) indexkey)->arg;
                if (equal(node, indexkey))
                {
                    result = makeVar(INDEX_VAR, indexcol + 1,
                                     exprType(lfirst(indexpr_item)), -1,
                                     exprCollation(lfirst(indexpr_item)),
                                     0);
                    return (Node *) result;
                }
                else
                    elog(ERROR, "index key does not match expected index column");
            }
            indexpr_item = lnext(index->indexprs, indexpr_item);
        }
    }
 
    /* Oops... */
    elog(ERROR, "index key does not match expected index column");
    return NULL;                /* keep compiler quiet */
}

References arg, Assert, copyObject, elog, equal(), ERROR, exprCollation(), exprType(), INDEX_VAR, IsA, lfirst, list_head(), lnext(), makeVar(), Var::varattno, and Var::varno.

Referenced by fix_indexqual_clause().

fix_indexqual_references()

static void fix_indexqual_references ( PlannerInfo *  root, IndexPath *  index_path, List **  stripped_indexquals_p, List **  fixed_indexquals_p  )

static

Definition at line 5017 of file createplan.c.

{
    IndexOptInfo *index = index_path->indexinfo;
    List       *stripped_indexquals;
    List       *fixed_indexquals;
    ListCell   *lc;
 
    stripped_indexquals = fixed_indexquals = NIL;
 
    foreach(lc, index_path->indexclauses)
    {
        IndexClause *iclause = lfirst_node(IndexClause, lc);
        int         indexcol = iclause->indexcol;
        ListCell   *lc2;
 
        foreach(lc2, iclause->indexquals)
        {
            RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc2);
            Node       *clause = (Node *) rinfo->clause;
 
            stripped_indexquals = lappend(stripped_indexquals, clause);
            clause = fix_indexqual_clause(root, index, indexcol,
                                          clause, iclause->indexcols);
            fixed_indexquals = lappend(fixed_indexquals, clause);
        }
    }
 
    *stripped_indexquals_p = stripped_indexquals;
    *fixed_indexquals_p = fixed_indexquals;
}

References RestrictInfo::clause, fix_indexqual_clause(), IndexPath::indexclauses, IndexClause::indexcol, IndexClause::indexcols, IndexPath::indexinfo, IndexClause::indexquals, lappend(), lfirst_node, NIL, and root.

Referenced by create_indexscan_plan().

get_gating_quals()

static List * get_gating_quals ( PlannerInfo *  root, List *  quals  )

static

Definition at line 1002 of file createplan.c.

{
    /* No need to look if we know there are no pseudoconstants */
    if (!root->hasPseudoConstantQuals)
        return NIL;
 
    /* Sort into desirable execution order while still in RestrictInfo form */
    quals = order_qual_clauses(root, quals);
 
    /* Pull out any pseudoconstant quals from the RestrictInfo list */
    return extract_actual_clauses(quals, true);
}

References extract_actual_clauses(), NIL, order_qual_clauses(), and root.

Referenced by create_join_plan(), and create_scan_plan().

get_switched_clauses()

static List * get_switched_clauses ( List *  clauses, Relids  outerrelids  )

static

Definition at line 5233 of file createplan.c.

{
    List       *t_list = NIL;
    ListCell   *l;
 
    foreach(l, clauses)
    {
        RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(l);
        OpExpr     *clause = (OpExpr *) restrictinfo->clause;
 
        Assert(is_opclause(clause));
        if (bms_is_subset(restrictinfo->right_relids, outerrelids))
        {
            /*
             * Duplicate just enough of the structure to allow commuting the
             * clause without changing the original list.  Could use
             * copyObject, but a complete deep copy is overkill.
             */
            OpExpr     *temp = makeNode(OpExpr);
 
            temp->opno = clause->opno;
            temp->opfuncid = InvalidOid;
            temp->opresulttype = clause->opresulttype;
            temp->opretset = clause->opretset;
            temp->opcollid = clause->opcollid;
            temp->inputcollid = clause->inputcollid;
            temp->args = list_copy(clause->args);
            temp->location = clause->location;
            /* Commute it --- note this modifies the temp node in-place. */
            CommuteOpExpr(temp);
            t_list = lappend(t_list, temp);
            restrictinfo->outer_is_left = false;
        }
        else
        {
            Assert(bms_is_subset(restrictinfo->left_relids, outerrelids));
            t_list = lappend(t_list, clause);
            restrictinfo->outer_is_left = true;
        }
    }
    return t_list;
}

References OpExpr::args, Assert, bms_is_subset(), RestrictInfo::clause, CommuteOpExpr(), InvalidOid, is_opclause(), lappend(), lfirst, list_copy(), OpExpr::location, makeNode, NIL, and OpExpr::opno.

Referenced by create_hashjoin_plan(), and create_mergejoin_plan().

inject_projection_plan()

static Plan * inject_projection_plan ( Plan *  subplan, List *  tlist, bool  parallel_safe  )

static

Definition at line 2115 of file createplan.c.

{
    Plan       *plan;
 
    plan = (Plan *) make_result(tlist, NULL, subplan);
 
    /*
     * In principle, we should charge tlist eval cost plus cpu_per_tuple per
     * row for the Result node.  But the former has probably been factored in
     * already and the latter was not accounted for during Path construction,
     * so being formally correct might just make the EXPLAIN output look less
     * consistent not more so.  Hence, just copy the subplan's cost.
     */
    copy_plan_costsize(plan, subplan);
    plan->parallel_safe = parallel_safe;
 
    return plan;
}

References copy_plan_costsize(), make_result(), and plan.

Referenced by change_plan_targetlist(), create_append_plan(), create_merge_append_plan(), and prepare_sort_from_pathkeys().

is_projection_capable_path()

bool is_projection_capable_path

(

Path *

path

)

Definition at line 7202 of file createplan.c.

{
    /* Most plan types can project, so just list the ones that can't */
    switch (path->pathtype)
    {
        case T_Hash:
        case T_Material:
        case T_Memoize:
        case T_Sort:
        case T_IncrementalSort:
        case T_Unique:
        case T_SetOp:
        case T_LockRows:
        case T_Limit:
        case T_ModifyTable:
        case T_MergeAppend:
        case T_RecursiveUnion:
            return false;
        case T_CustomScan:
            if (castNode(CustomPath, path)->flags & CUSTOMPATH_SUPPORT_PROJECTION)
                return true;
            return false;
        case T_Append:
 
            /*
             * Append can't project, but if an AppendPath is being used to
             * represent a dummy path, what will actually be generated is a
             * Result which can project.
             */
            return IS_DUMMY_APPEND(path);
        case T_ProjectSet:
 
            /*
             * Although ProjectSet certainly projects, say "no" because we
             * don't want the planner to randomly replace its tlist with
             * something else; the SRFs have to stay at top level.  This might
             * get relaxed later.
             */
            return false;
        default:
            break;
    }
    return true;
}

References castNode, CUSTOMPATH_SUPPORT_PROJECTION, IS_DUMMY_APPEND, and Path::pathtype.

Referenced by add_paths_with_pathkeys_for_rel(), apply_projection_to_path(), create_projection_path(), and create_projection_plan().

is_projection_capable_plan()

bool is_projection_capable_plan

(

Plan *

plan

)

Definition at line 7252 of file createplan.c.

{
    /* Most plan types can project, so just list the ones that can't */
    switch (nodeTag(plan))
    {
        case T_Hash:
        case T_Material:
        case T_Memoize:
        case T_Sort:
        case T_Unique:
        case T_SetOp:
        case T_LockRows:
        case T_Limit:
        case T_ModifyTable:
        case T_Append:
        case T_MergeAppend:
        case T_RecursiveUnion:
            return false;
        case T_CustomScan:
            if (((CustomScan *) plan)->flags & CUSTOMPATH_SUPPORT_PROJECTION)
                return true;
            return false;
        case T_ProjectSet:
 
            /*
             * Although ProjectSet certainly projects, say "no" because we
             * don't want the planner to randomly replace its tlist with
             * something else; the SRFs have to stay at top level.  This might
             * get relaxed later.
             */
            return false;
        default:
            break;
    }
    return true;
}

References CUSTOMPATH_SUPPORT_PROJECTION, nodeTag, and plan.

Referenced by change_plan_targetlist(), create_projection_plan(), and prepare_sort_from_pathkeys().

label_sort_with_costsize()

static void label_sort_with_costsize ( PlannerInfo *  root, Sort *  plan, double  limit_tuples  )

static

Definition at line 5441 of file createplan.c.

{
    Plan       *lefttree = plan->plan.lefttree;
    Path        sort_path;      /* dummy for result of cost_sort */
 
    /*
     * This function shouldn't have to deal with IncrementalSort plans because
     * they are only created from corresponding Path nodes.
     */
    Assert(IsA(plan, Sort));
 
    cost_sort(&sort_path, root, NIL,
              lefttree->total_cost,
              lefttree->plan_rows,
              lefttree->plan_width,
              0.0,
              work_mem,
              limit_tuples);
    plan->plan.startup_cost = sort_path.startup_cost;
    plan->plan.total_cost = sort_path.total_cost;
    plan->plan.plan_rows = lefttree->plan_rows;
    plan->plan.plan_width = lefttree->plan_width;
    plan->plan.parallel_aware = false;
    plan->plan.parallel_safe = lefttree->parallel_safe;
}

References Assert, cost_sort(), IsA, NIL, Plan::parallel_safe, plan, Plan::plan_rows, Plan::plan_width, root, Path::startup_cost, Path::total_cost, Plan::total_cost, and work_mem.

Referenced by create_append_plan(), create_merge_append_plan(), create_mergejoin_plan(), and create_unique_plan().

make_agg()

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
	)

Definition at line 6588 of file createplan.c.

{
    Agg        *node = makeNode(Agg);
    Plan       *plan = &node->plan;
    long        numGroups;
 
    /* Reduce to long, but 'ware overflow! */
    numGroups = clamp_cardinality_to_long(dNumGroups);
 
    node->aggstrategy = aggstrategy;
    node->aggsplit = aggsplit;
    node->numCols = numGroupCols;
    node->grpColIdx = grpColIdx;
    node->grpOperators = grpOperators;
    node->grpCollations = grpCollations;
    node->numGroups = numGroups;
    node->transitionSpace = transitionSpace;
    node->aggParams = NULL;     /* SS_finalize_plan() will fill this */
    node->groupingSets = groupingSets;
    node->chain = chain;
 
    plan->qual = qual;
    plan->targetlist = tlist;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    return node;
}

References Agg::aggParams, Agg::aggsplit, Agg::aggstrategy, Agg::chain, clamp_cardinality_to_long(), Agg::groupingSets, makeNode, Agg::numCols, Agg::numGroups, Agg::plan, plan, and Agg::transitionSpace.

Referenced by create_agg_plan(), create_groupingsets_plan(), and create_unique_plan().

make_bitmap_and()

static BitmapAnd * make_bitmap_and ( List *  bitmapplans )

static

Definition at line 5913 of file createplan.c.

{
    BitmapAnd  *node = makeNode(BitmapAnd);
    Plan       *plan = &node->plan;
 
    plan->targetlist = NIL;
    plan->qual = NIL;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->bitmapplans = bitmapplans;
 
    return node;
}

References BitmapAnd::bitmapplans, makeNode, NIL, BitmapAnd::plan, and plan.

Referenced by create_bitmap_subplan().

make_bitmap_heapscan()

static BitmapHeapScan * make_bitmap_heapscan ( List *  qptlist, List *  qpqual, Plan *  lefttree, List *  bitmapqualorig, Index  scanrelid  )

static

Definition at line 5620 of file createplan.c.

{
    BitmapHeapScan *node = makeNode(BitmapHeapScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->bitmapqualorig = bitmapqualorig;
 
    return node;
}

References BitmapHeapScan::bitmapqualorig, makeNode, plan, BitmapHeapScan::scan, and Scan::scanrelid.

Referenced by create_bitmap_scan_plan().

make_bitmap_indexscan()

static BitmapIndexScan * make_bitmap_indexscan ( Index  scanrelid, Oid  indexid, List *  indexqual, List *  indexqualorig  )

static

Definition at line 5599 of file createplan.c.

{
    BitmapIndexScan *node = makeNode(BitmapIndexScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = NIL;     /* not used */
    plan->qual = NIL;           /* not used */
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->indexid = indexid;
    node->indexqual = indexqual;
    node->indexqualorig = indexqualorig;
 
    return node;
}

References BitmapIndexScan::indexid, BitmapIndexScan::indexqual, BitmapIndexScan::indexqualorig, makeNode, NIL, plan, BitmapIndexScan::scan, and Scan::scanrelid.

Referenced by create_bitmap_subplan().

make_bitmap_or()

static BitmapOr * make_bitmap_or ( List *  bitmapplans )

static

Definition at line 5928 of file createplan.c.

{
    BitmapOr   *node = makeNode(BitmapOr);
    Plan       *plan = &node->plan;
 
    plan->targetlist = NIL;
    plan->qual = NIL;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->bitmapplans = bitmapplans;
 
    return node;
}

References BitmapOr::bitmapplans, makeNode, NIL, BitmapOr::plan, and plan.

Referenced by create_bitmap_subplan().

make_ctescan()

static CteScan * make_ctescan ( List *  qptlist, List *  qpqual, Index  scanrelid, int  ctePlanId, int  cteParam  )

static

Definition at line 5757 of file createplan.c.

{
    CteScan    *node = makeNode(CteScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->ctePlanId = ctePlanId;
    node->cteParam = cteParam;
 
    return node;
}

References CteScan::cteParam, CteScan::ctePlanId, makeNode, plan, CteScan::scan, and Scan::scanrelid.

Referenced by create_ctescan_plan().

make_foreignscan()

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
	)

Definition at line 5817 of file createplan.c.

{
    ForeignScan *node = makeNode(ForeignScan);
    Plan       *plan = &node->scan.plan;
 
    /* cost will be filled in by create_foreignscan_plan */
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = outer_plan;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
 
    /* these may be overridden by the FDW's PlanDirectModify callback. */
    node->operation = CMD_SELECT;
    node->resultRelation = 0;
 
    /* checkAsUser, fs_server will be filled in by create_foreignscan_plan */
    node->checkAsUser = InvalidOid;
    node->fs_server = InvalidOid;
    node->fdw_exprs = fdw_exprs;
    node->fdw_private = fdw_private;
    node->fdw_scan_tlist = fdw_scan_tlist;
    node->fdw_recheck_quals = fdw_recheck_quals;
    /* fs_relids, fs_base_relids will be filled by create_foreignscan_plan */
    node->fs_relids = NULL;
    node->fs_base_relids = NULL;
    /* fsSystemCol will be filled in by create_foreignscan_plan */
    node->fsSystemCol = false;
 
    return node;
}

References ForeignScan::checkAsUser, CMD_SELECT, ForeignScan::fdw_exprs, ForeignScan::fdw_private, ForeignScan::fdw_recheck_quals, ForeignScan::fdw_scan_tlist, ForeignScan::fs_base_relids, ForeignScan::fs_relids, ForeignScan::fs_server, ForeignScan::fsSystemCol, InvalidOid, makeNode, ForeignScan::operation, plan, ForeignScan::resultRelation, ForeignScan::scan, and Scan::scanrelid.

Referenced by fileGetForeignPlan(), and postgresGetForeignPlan().

make_functionscan()

static FunctionScan * make_functionscan ( List *  qptlist, List *  qpqual, Index  scanrelid, List *  functions, bool  funcordinality  )

static

Definition at line 5698 of file createplan.c.

{
    FunctionScan *node = makeNode(FunctionScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->functions = functions;
    node->funcordinality = funcordinality;
 
    return node;
}

References FunctionScan::funcordinality, functions, FunctionScan::functions, makeNode, plan, FunctionScan::scan, and Scan::scanrelid.

Referenced by create_functionscan_plan().

make_gather()

static Gather * make_gather ( List *  qptlist, List *  qpqual, int  nworkers, int  rescan_param, bool  single_copy, Plan *  subplan  )

static

Definition at line 6849 of file createplan.c.

{
    Gather     *node = makeNode(Gather);
    Plan       *plan = &node->plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = subplan;
    plan->righttree = NULL;
    node->num_workers = nworkers;
    node->rescan_param = rescan_param;
    node->single_copy = single_copy;
    node->invisible = false;
    node->initParam = NULL;
 
    return node;
}

References Gather::initParam, Gather::invisible, makeNode, Gather::num_workers, Gather::plan, plan, Gather::rescan_param, and Gather::single_copy.

Referenced by create_gather_plan().

make_group()

static Group * make_group ( List *  tlist, List *  qual, int  numGroupCols, AttrNumber *  grpColIdx, Oid *  grpOperators, Oid *  grpCollations, Plan *  lefttree  )

static

Definition at line 6664 of file createplan.c.

{
    Group      *node = makeNode(Group);
    Plan       *plan = &node->plan;
 
    node->numCols = numGroupCols;
    node->grpColIdx = grpColIdx;
    node->grpOperators = grpOperators;
    node->grpCollations = grpCollations;
 
    plan->qual = qual;
    plan->targetlist = tlist;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    return node;
}

References makeNode, Group::numCols, Group::plan, and plan.

Referenced by create_group_plan().

make_hash()

static Hash * make_hash ( Plan *  lefttree, List *  hashkeys, Oid  skewTable, AttrNumber  skewColumn, bool  skewInherit  )

static

Definition at line 5999 of file createplan.c.

{
    Hash       *node = makeNode(Hash);
    Plan       *plan = &node->plan;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    node->hashkeys = hashkeys;
    node->skewTable = skewTable;
    node->skewColumn = skewColumn;
    node->skewInherit = skewInherit;
 
    return node;
}

References Hash::hashkeys, makeNode, NIL, Hash::plan, plan, Hash::skewColumn, Hash::skewInherit, Hash::skewTable, and Plan::targetlist.

Referenced by create_hashjoin_plan().

make_hashjoin()

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

Definition at line 5968 of file createplan.c.

{
    HashJoin   *node = makeNode(HashJoin);
    Plan       *plan = &node->join.plan;
 
    plan->targetlist = tlist;
    plan->qual = otherclauses;
    plan->lefttree = lefttree;
    plan->righttree = righttree;
    node->hashclauses = hashclauses;
    node->hashoperators = hashoperators;
    node->hashcollations = hashcollations;
    node->hashkeys = hashkeys;
    node->join.jointype = jointype;
    node->join.inner_unique = inner_unique;
    node->join.joinqual = joinclauses;
 
    return node;
}

References HashJoin::hashclauses, HashJoin::hashcollations, HashJoin::hashkeys, HashJoin::hashoperators, Join::inner_unique, HashJoin::join, Join::joinqual, Join::jointype, makeNode, and plan.

Referenced by create_hashjoin_plan().

make_incrementalsort()

static IncrementalSort * make_incrementalsort ( Plan *  lefttree, int  numCols, int  nPresortedCols, AttrNumber *  sortColIdx, Oid *  sortOperators, Oid *  collations, bool *  nullsFirst  )

static

Definition at line 6093 of file createplan.c.

{
    IncrementalSort *node;
    Plan       *plan;
 
    node = makeNode(IncrementalSort);
 
    plan = &node->sort.plan;
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
    node->nPresortedCols = nPresortedCols;
    node->sort.numCols = numCols;
    node->sort.sortColIdx = sortColIdx;
    node->sort.sortOperators = sortOperators;
    node->sort.collations = collations;
    node->sort.nullsFirst = nullsFirst;
 
    return node;
}

References makeNode, NIL, IncrementalSort::nPresortedCols, Sort::numCols, Sort::plan, plan, IncrementalSort::sort, and Plan::targetlist.

Referenced by make_incrementalsort_from_pathkeys().

make_incrementalsort_from_pathkeys()

static IncrementalSort * make_incrementalsort_from_pathkeys ( Plan *  lefttree, List *  pathkeys, Relids  relids, int  nPresortedCols  )

static

Definition at line 6376 of file createplan.c.

{
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;
 
    /* Compute sort column info, and adjust lefttree as needed */
    lefttree = prepare_sort_from_pathkeys(lefttree, pathkeys,
                                          relids,
                                          NULL,
                                          false,
                                          &numsortkeys,
                                          &sortColIdx,
                                          &sortOperators,
                                          &collations,
                                          &nullsFirst);
 
    /* Now build the Sort node */
    return make_incrementalsort(lefttree, numsortkeys, nPresortedCols,
                                sortColIdx, sortOperators,
                                collations, nullsFirst);
}

References make_incrementalsort(), and prepare_sort_from_pathkeys().

Referenced by create_incrementalsort_plan().

make_indexonlyscan()

static IndexOnlyScan * make_indexonlyscan ( List *  qptlist, List *  qpqual, Index  scanrelid, Oid  indexid, List *  indexqual, List *  recheckqual, List *  indexorderby, List *  indextlist, ScanDirection  indexscandir  )

static

Definition at line 5570 of file createplan.c.

{
    IndexOnlyScan *node = makeNode(IndexOnlyScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->indexid = indexid;
    node->indexqual = indexqual;
    node->recheckqual = recheckqual;
    node->indexorderby = indexorderby;
    node->indextlist = indextlist;
    node->indexorderdir = indexscandir;
 
    return node;
}

References IndexOnlyScan::indexid, IndexOnlyScan::indexorderby, IndexOnlyScan::indexorderdir, IndexOnlyScan::indexqual, IndexOnlyScan::indextlist, makeNode, plan, IndexOnlyScan::recheckqual, IndexOnlyScan::scan, and Scan::scanrelid.

Referenced by create_indexscan_plan().

make_indexscan()

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

Definition at line 5539 of file createplan.c.

{
    IndexScan  *node = makeNode(IndexScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->indexid = indexid;
    node->indexqual = indexqual;
    node->indexqualorig = indexqualorig;
    node->indexorderby = indexorderby;
    node->indexorderbyorig = indexorderbyorig;
    node->indexorderbyops = indexorderbyops;
    node->indexorderdir = indexscandir;
 
    return node;
}

References IndexScan::indexid, IndexScan::indexorderby, IndexScan::indexorderbyops, IndexScan::indexorderbyorig, IndexScan::indexorderdir, IndexScan::indexqual, IndexScan::indexqualorig, makeNode, plan, IndexScan::scan, and Scan::scanrelid.

Referenced by create_indexscan_plan().

make_limit()

Limit* make_limit	(	Plan *	lefttree,
		Node *	limitOffset,
		Node *	limitCount,
		LimitOption	limitOption,
		int	uniqNumCols,
		AttrNumber *	uniqColIdx,
		Oid *	uniqOperators,
		Oid *	uniqCollations
	)

Definition at line 6955 of file createplan.c.

{
    Limit      *node = makeNode(Limit);
    Plan       *plan = &node->plan;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    node->limitOffset = limitOffset;
    node->limitCount = limitCount;
    node->limitOption = limitOption;
    node->uniqNumCols = uniqNumCols;
    node->uniqColIdx = uniqColIdx;
    node->uniqOperators = uniqOperators;
    node->uniqCollations = uniqCollations;
 
    return node;
}

References Limit::limitCount, Limit::limitOffset, Limit::limitOption, makeNode, NIL, Limit::plan, plan, Plan::targetlist, and Limit::uniqNumCols.

Referenced by create_limit_plan(), and create_minmaxagg_plan().

make_lockrows()

static LockRows * make_lockrows ( Plan *  lefttree, List *  rowMarks, int  epqParam  )

static

Definition at line 6934 of file createplan.c.

{
    LockRows   *node = makeNode(LockRows);
    Plan       *plan = &node->plan;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    node->rowMarks = rowMarks;
    node->epqParam = epqParam;
 
    return node;
}

References LockRows::epqParam, makeNode, NIL, LockRows::plan, plan, LockRows::rowMarks, and Plan::targetlist.

Referenced by create_lockrows_plan().

make_material()

static Material * make_material ( Plan *  lefttree )

static

Definition at line 6500 of file createplan.c.

{
    Material   *node = makeNode(Material);
    Plan       *plan = &node->plan;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    return node;
}

References makeNode, NIL, Material::plan, plan, and Plan::targetlist.

Referenced by create_material_plan(), create_mergejoin_plan(), and materialize_finished_plan().

make_memoize()

static Memoize * make_memoize ( Plan *  lefttree, Oid *  hashoperators, Oid *  collations, List *  param_exprs, bool  singlerow, bool  binary_mode, uint32  est_entries, Bitmapset *  keyparamids  )

static

Definition at line 6563 of file createplan.c.

{
    Memoize    *node = makeNode(Memoize);
    Plan       *plan = &node->plan;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    node->numKeys = list_length(param_exprs);
    node->hashOperators = hashoperators;
    node->collations = collations;
    node->param_exprs = param_exprs;
    node->singlerow = singlerow;
    node->binary_mode = binary_mode;
    node->est_entries = est_entries;
    node->keyparamids = keyparamids;
 
    return node;
}

References Memoize::binary_mode, Memoize::est_entries, Memoize::keyparamids, list_length(), makeNode, NIL, Memoize::numKeys, Memoize::param_exprs, Memoize::plan, plan, Memoize::singlerow, and Plan::targetlist.

Referenced by create_memoize_plan().

make_mergejoin()

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

Definition at line 6022 of file createplan.c.

{
    MergeJoin  *node = makeNode(MergeJoin);
    Plan       *plan = &node->join.plan;
 
    plan->targetlist = tlist;
    plan->qual = otherclauses;
    plan->lefttree = lefttree;
    plan->righttree = righttree;
    node->skip_mark_restore = skip_mark_restore;
    node->mergeclauses = mergeclauses;
    node->mergeFamilies = mergefamilies;
    node->mergeCollations = mergecollations;
    node->mergeStrategies = mergestrategies;
    node->mergeNullsFirst = mergenullsfirst;
    node->join.jointype = jointype;
    node->join.inner_unique = inner_unique;
    node->join.joinqual = joinclauses;
 
    return node;
}

References Join::inner_unique, MergeJoin::join, Join::joinqual, Join::jointype, makeNode, MergeJoin::mergeclauses, plan, and MergeJoin::skip_mark_restore.

Referenced by create_mergejoin_plan().

make_modifytable()

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, List *  mergeJoinConditions, int  epqParam  )

static

Definition at line 7023 of file createplan.c.

{
    ModifyTable *node = makeNode(ModifyTable);
    List       *fdw_private_list;
    Bitmapset  *direct_modify_plans;
    ListCell   *lc;
    int         i;
 
    Assert(operation == CMD_MERGE ||
           (operation == CMD_UPDATE ?
            list_length(resultRelations) == list_length(updateColnosLists) :
            updateColnosLists == NIL));
    Assert(withCheckOptionLists == NIL ||
           list_length(resultRelations) == list_length(withCheckOptionLists));
    Assert(returningLists == NIL ||
           list_length(resultRelations) == list_length(returningLists));
 
    node->plan.lefttree = subplan;
    node->plan.righttree = NULL;
    node->plan.qual = NIL;
    /* setrefs.c will fill in the targetlist, if needed */
    node->plan.targetlist = NIL;
 
    node->operation = operation;
    node->canSetTag = canSetTag;
    node->nominalRelation = nominalRelation;
    node->rootRelation = rootRelation;
    node->partColsUpdated = partColsUpdated;
    node->resultRelations = resultRelations;
    if (!onconflict)
    {
        node->onConflictAction = ONCONFLICT_NONE;
        node->onConflictSet = NIL;
        node->onConflictCols = NIL;
        node->onConflictWhere = NULL;
        node->arbiterIndexes = NIL;
        node->exclRelRTI = 0;
        node->exclRelTlist = NIL;
    }
    else
    {
        node->onConflictAction = onconflict->action;
 
        /*
         * Here we convert the ON CONFLICT UPDATE tlist, if any, to the
         * executor's convention of having consecutive resno's.  The actual
         * target column numbers are saved in node->onConflictCols.  (This
         * could be done earlier, but there seems no need to.)
         */
        node->onConflictSet = onconflict->onConflictSet;
        node->onConflictCols =
            extract_update_targetlist_colnos(node->onConflictSet);
        node->onConflictWhere = onconflict->onConflictWhere;
 
        /*
         * If a set of unique index inference elements was provided (an
         * INSERT...ON CONFLICT "inference specification"), then infer
         * appropriate unique indexes (or throw an error if none are
         * available).
         */
        node->arbiterIndexes = infer_arbiter_indexes(root);
 
        node->exclRelRTI = onconflict->exclRelIndex;
        node->exclRelTlist = onconflict->exclRelTlist;
    }
    node->updateColnosLists = updateColnosLists;
    node->withCheckOptionLists = withCheckOptionLists;
    node->returningLists = returningLists;
    node->rowMarks = rowMarks;
    node->mergeActionLists = mergeActionLists;
    node->mergeJoinConditions = mergeJoinConditions;
    node->epqParam = epqParam;
 
    /*
     * For each result relation that is a foreign table, allow the FDW to
     * construct private plan data, and accumulate it all into a list.
     */
    fdw_private_list = NIL;
    direct_modify_plans = NULL;
    i = 0;
    foreach(lc, resultRelations)
    {
        Index       rti = lfirst_int(lc);
        FdwRoutine *fdwroutine;
        List       *fdw_private;
        bool        direct_modify;
 
        /*
         * If possible, we want to get the FdwRoutine from our RelOptInfo for
         * the table.  But sometimes we don't have a RelOptInfo and must get
         * it the hard way.  (In INSERT, the target relation is not scanned,
         * so it's not a baserel; and there are also corner cases for
         * updatable views where the target rel isn't a baserel.)
         */
        if (rti < root->simple_rel_array_size &&
            root->simple_rel_array[rti] != NULL)
        {
            RelOptInfo *resultRel = root->simple_rel_array[rti];
 
            fdwroutine = resultRel->fdwroutine;
        }
        else
        {
            RangeTblEntry *rte = planner_rt_fetch(rti, root);
 
            if (rte->rtekind == RTE_RELATION &&
                rte->relkind == RELKIND_FOREIGN_TABLE)
                fdwroutine = GetFdwRoutineByRelId(rte->relid);
            else
                fdwroutine = NULL;
        }
 
        /*
         * MERGE is not currently supported for foreign tables.  We already
         * checked that when the table mentioned in the query is foreign; but
         * we can still get here if a partitioned table has a foreign table as
         * partition.  Disallow that now, to avoid an uglier error message
         * later.
         */
        if (operation == CMD_MERGE && fdwroutine != NULL)
        {
            RangeTblEntry *rte = planner_rt_fetch(rti, root);
 
            ereport(ERROR,
                    errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                    errmsg("cannot execute MERGE on relation \"%s\"",
                           get_rel_name(rte->relid)),
                    errdetail_relkind_not_supported(rte->relkind));
        }
 
        /*
         * Try to modify the foreign table directly if (1) the FDW provides
         * callback functions needed for that and (2) there are no local
         * structures that need to be run for each modified row: row-level
         * triggers on the foreign table, stored generated columns, WITH CHECK
         * OPTIONs from parent views.
         */
        direct_modify = false;
        if (fdwroutine != NULL &&
            fdwroutine->PlanDirectModify != NULL &&
            fdwroutine->BeginDirectModify != NULL &&
            fdwroutine->IterateDirectModify != NULL &&
            fdwroutine->EndDirectModify != NULL &&
            withCheckOptionLists == NIL &&
            !has_row_triggers(root, rti, operation) &&
            !has_stored_generated_columns(root, rti))
            direct_modify = fdwroutine->PlanDirectModify(root, node, rti, i);
        if (direct_modify)
            direct_modify_plans = bms_add_member(direct_modify_plans, i);
 
        if (!direct_modify &&
            fdwroutine != NULL &&
            fdwroutine->PlanForeignModify != NULL)
            fdw_private = fdwroutine->PlanForeignModify(root, node, rti, i);
        else
            fdw_private = NIL;
        fdw_private_list = lappend(fdw_private_list, fdw_private);
        i++;
    }
    node->fdwPrivLists = fdw_private_list;
    node->fdwDirectModifyPlans = direct_modify_plans;
 
    return node;
}

References OnConflictExpr::action, ModifyTable::arbiterIndexes, Assert, FdwRoutine::BeginDirectModify, bms_add_member(), ModifyTable::canSetTag, CMD_MERGE, CMD_UPDATE, FdwRoutine::EndDirectModify, ModifyTable::epqParam, ereport, errcode(), errdetail_relkind_not_supported(), errmsg(), ERROR, OnConflictExpr::exclRelIndex, ModifyTable::exclRelRTI, ModifyTable::exclRelTlist, OnConflictExpr::exclRelTlist, extract_update_targetlist_colnos(), ModifyTable::fdwDirectModifyPlans, ModifyTable::fdwPrivLists, get_rel_name(), GetFdwRoutineByRelId(), has_row_triggers(), has_stored_generated_columns(), i, infer_arbiter_indexes(), FdwRoutine::IterateDirectModify, lappend(), Plan::lefttree, lfirst_int, list_length(), makeNode, ModifyTable::mergeActionLists, ModifyTable::mergeJoinConditions, NIL, ModifyTable::nominalRelation, ONCONFLICT_NONE, ModifyTable::onConflictAction, ModifyTable::onConflictCols, ModifyTable::onConflictSet, OnConflictExpr::onConflictSet, ModifyTable::onConflictWhere, OnConflictExpr::onConflictWhere, ModifyTable::operation, ModifyTable::partColsUpdated, ModifyTable::plan, FdwRoutine::PlanDirectModify, FdwRoutine::PlanForeignModify, planner_rt_fetch, Plan::qual, RangeTblEntry::relid, ModifyTable::resultRelations, ModifyTable::returningLists, Plan::righttree, root, ModifyTable::rootRelation, ModifyTable::rowMarks, RTE_RELATION, RangeTblEntry::rtekind, Plan::targetlist, ModifyTable::updateColnosLists, and ModifyTable::withCheckOptionLists.

Referenced by create_modifytable_plan().

make_namedtuplestorescan()

static NamedTuplestoreScan * make_namedtuplestorescan ( List *  qptlist, List *  qpqual, Index  scanrelid, char *  enrname  )

static

Definition at line 5778 of file createplan.c.

{
    NamedTuplestoreScan *node = makeNode(NamedTuplestoreScan);
    Plan       *plan = &node->scan.plan;
 
    /* cost should be inserted by caller */
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->enrname = enrname;
 
    return node;
}

References NamedTuplestoreScan::enrname, makeNode, plan, NamedTuplestoreScan::scan, and Scan::scanrelid.

Referenced by create_namedtuplestorescan_plan().

make_nestloop()

static NestLoop * make_nestloop ( List *  tlist, List *  joinclauses, List *  otherclauses, List *  nestParams, Plan *  lefttree, Plan *  righttree, JoinType  jointype, bool  inner_unique  )

static

Definition at line 5943 of file createplan.c.

{
    NestLoop   *node = makeNode(NestLoop);
    Plan       *plan = &node->join.plan;
 
    plan->targetlist = tlist;
    plan->qual = otherclauses;
    plan->lefttree = lefttree;
    plan->righttree = righttree;
    node->join.jointype = jointype;
    node->join.inner_unique = inner_unique;
    node->join.joinqual = joinclauses;
    node->nestParams = nestParams;
 
    return node;
}

References Join::inner_unique, NestLoop::join, Join::joinqual, Join::jointype, makeNode, NestLoop::nestParams, and plan.

Referenced by create_nestloop_plan().

make_project_set()

static ProjectSet * make_project_set ( List *  tlist, Plan *  subplan  )

static

Definition at line 7004 of file createplan.c.

{
    ProjectSet *node = makeNode(ProjectSet);
    Plan       *plan = &node->plan;
 
    plan->targetlist = tlist;
    plan->qual = NIL;
    plan->lefttree = subplan;
    plan->righttree = NULL;
 
    return node;
}

References makeNode, NIL, ProjectSet::plan, and plan.

Referenced by create_project_set_plan().

make_recursive_union()

static RecursiveUnion * make_recursive_union ( List *  tlist, Plan *  lefttree, Plan *  righttree, int  wtParam, List *  distinctList, long  numGroups  )

static

Definition at line 5857 of file createplan.c.

{
    RecursiveUnion *node = makeNode(RecursiveUnion);
    Plan       *plan = &node->plan;
    int         numCols = list_length(distinctList);
 
    plan->targetlist = tlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = righttree;
    node->wtParam = wtParam;
 
    /*
     * convert SortGroupClause list into arrays of attr indexes and equality
     * operators, as wanted by executor
     */
    node->numCols = numCols;
    if (numCols > 0)
    {
        int         keyno = 0;
        AttrNumber *dupColIdx;
        Oid        *dupOperators;
        Oid        *dupCollations;
        ListCell   *slitem;
 
        dupColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
        dupOperators = (Oid *) palloc(sizeof(Oid) * numCols);
        dupCollations = (Oid *) palloc(sizeof(Oid) * numCols);
 
        foreach(slitem, distinctList)
        {
            SortGroupClause *sortcl = (SortGroupClause *) lfirst(slitem);
            TargetEntry *tle = get_sortgroupclause_tle(sortcl,
                                                       plan->targetlist);
 
            dupColIdx[keyno] = tle->resno;
            dupOperators[keyno] = sortcl->eqop;
            dupCollations[keyno] = exprCollation((Node *) tle->expr);
            Assert(OidIsValid(dupOperators[keyno]));
            keyno++;
        }
        node->dupColIdx = dupColIdx;
        node->dupOperators = dupOperators;
        node->dupCollations = dupCollations;
    }
    node->numGroups = numGroups;
 
    return node;
}

References Assert, SortGroupClause::eqop, TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, list_length(), makeNode, NIL, RecursiveUnion::numCols, RecursiveUnion::numGroups, OidIsValid, palloc(), RecursiveUnion::plan, plan, TargetEntry::resno, and RecursiveUnion::wtParam.

Referenced by create_recursiveunion_plan().

make_result()

static Result * make_result ( List *  tlist, Node *  resconstantqual, Plan *  subplan  )

static

Definition at line 6983 of file createplan.c.

{
    Result     *node = makeNode(Result);
    Plan       *plan = &node->plan;
 
    plan->targetlist = tlist;
    plan->qual = NIL;
    plan->lefttree = subplan;
    plan->righttree = NULL;
    node->resconstantqual = resconstantqual;
 
    return node;
}

References makeNode, NIL, Result::plan, plan, and Result::resconstantqual.

Referenced by create_append_plan(), create_gating_plan(), create_group_result_plan(), create_minmaxagg_plan(), create_projection_plan(), create_resultscan_plan(), and inject_projection_plan().

make_samplescan()

static SampleScan * make_samplescan ( List *  qptlist, List *  qpqual, Index  scanrelid, TableSampleClause *  tsc  )

static

Definition at line 5520 of file createplan.c.

{
    SampleScan *node = makeNode(SampleScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->tablesample = tsc;
 
    return node;
}

References makeNode, plan, SampleScan::scan, Scan::scanrelid, and SampleScan::tablesample.

Referenced by create_samplescan_plan().

make_seqscan()

static SeqScan * make_seqscan ( List *  qptlist, List *  qpqual, Index  scanrelid  )

static

Definition at line 5503 of file createplan.c.

{
    SeqScan    *node = makeNode(SeqScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
 
    return node;
}

References makeNode, plan, SeqScan::scan, and Scan::scanrelid.

Referenced by create_seqscan_plan().

make_setop()

static SetOp * make_setop ( SetOpCmd  cmd, SetOpStrategy  strategy, Plan *  lefttree, List *  distinctList, AttrNumber  flagColIdx, int  firstFlag, long  numGroups  )

static

Definition at line 6878 of file createplan.c.

{
    SetOp      *node = makeNode(SetOp);
    Plan       *plan = &node->plan;
    int         numCols = list_length(distinctList);
    int         keyno = 0;
    AttrNumber *dupColIdx;
    Oid        *dupOperators;
    Oid        *dupCollations;
    ListCell   *slitem;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    /*
     * convert SortGroupClause list into arrays of attr indexes and equality
     * operators, as wanted by executor
     */
    dupColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
    dupOperators = (Oid *) palloc(sizeof(Oid) * numCols);
    dupCollations = (Oid *) palloc(sizeof(Oid) * numCols);
 
    foreach(slitem, distinctList)
    {
        SortGroupClause *sortcl = (SortGroupClause *) lfirst(slitem);
        TargetEntry *tle = get_sortgroupclause_tle(sortcl, plan->targetlist);
 
        dupColIdx[keyno] = tle->resno;
        dupOperators[keyno] = sortcl->eqop;
        dupCollations[keyno] = exprCollation((Node *) tle->expr);
        Assert(OidIsValid(dupOperators[keyno]));
        keyno++;
    }
 
    node->cmd = cmd;
    node->strategy = strategy;
    node->numCols = numCols;
    node->dupColIdx = dupColIdx;
    node->dupOperators = dupOperators;
    node->dupCollations = dupCollations;
    node->flagColIdx = flagColIdx;
    node->firstFlag = firstFlag;
    node->numGroups = numGroups;
 
    return node;
}

References Assert, SetOp::cmd, SortGroupClause::eqop, TargetEntry::expr, exprCollation(), SetOp::firstFlag, SetOp::flagColIdx, get_sortgroupclause_tle(), lfirst, list_length(), makeNode, NIL, SetOp::numCols, SetOp::numGroups, OidIsValid, palloc(), SetOp::plan, plan, TargetEntry::resno, SetOp::strategy, and Plan::targetlist.

Referenced by create_setop_plan().

make_sort()

static Sort * make_sort ( Plan *  lefttree, int  numCols, AttrNumber *  sortColIdx, Oid *  sortOperators, Oid *  collations, bool *  nullsFirst  )

static

Definition at line 6063 of file createplan.c.

{
    Sort       *node;
    Plan       *plan;
 
    node = makeNode(Sort);
 
    plan = &node->plan;
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
    node->numCols = numCols;
    node->sortColIdx = sortColIdx;
    node->sortOperators = sortOperators;
    node->collations = collations;
    node->nullsFirst = nullsFirst;
 
    return node;
}

References makeNode, NIL, Sort::numCols, Sort::plan, plan, and Plan::targetlist.

Referenced by create_append_plan(), create_merge_append_plan(), make_sort_from_groupcols(), make_sort_from_pathkeys(), and make_sort_from_sortclauses().

make_sort_from_groupcols()

static Sort * make_sort_from_groupcols ( List *  groupcls, AttrNumber *  grpColIdx, Plan *  lefttree  )

static

Definition at line 6459 of file createplan.c.

{
    List       *sub_tlist = lefttree->targetlist;
    ListCell   *l;
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;
 
    /* Convert list-ish representation to arrays wanted by executor */
    numsortkeys = list_length(groupcls);
    sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
    sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
    collations = (Oid *) palloc(numsortkeys * sizeof(Oid));
    nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool));
 
    numsortkeys = 0;
    foreach(l, groupcls)
    {
        SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
        TargetEntry *tle = get_tle_by_resno(sub_tlist, grpColIdx[numsortkeys]);
 
        if (!tle)
            elog(ERROR, "could not retrieve tle for sort-from-groupcols");
 
        sortColIdx[numsortkeys] = tle->resno;
        sortOperators[numsortkeys] = grpcl->sortop;
        collations[numsortkeys] = exprCollation((Node *) tle->expr);
        nullsFirst[numsortkeys] = grpcl->nulls_first;
        numsortkeys++;
    }
 
    return make_sort(lefttree, numsortkeys,
                     sortColIdx, sortOperators,
                     collations, nullsFirst);
}

References elog, ERROR, TargetEntry::expr, exprCollation(), get_tle_by_resno(), lfirst, list_length(), make_sort(), SortGroupClause::nulls_first, palloc(), TargetEntry::resno, SortGroupClause::sortop, and Plan::targetlist.

Referenced by create_groupingsets_plan().

make_sort_from_pathkeys()

static Sort * make_sort_from_pathkeys ( Plan *  lefttree, List *  pathkeys, Relids  relids  )

static

Definition at line 6341 of file createplan.c.

{
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;
 
    /* Compute sort column info, and adjust lefttree as needed */
    lefttree = prepare_sort_from_pathkeys(lefttree, pathkeys,
                                          relids,
                                          NULL,
                                          false,
                                          &numsortkeys,
                                          &sortColIdx,
                                          &sortOperators,
                                          &collations,
                                          &nullsFirst);
 
    /* Now build the Sort node */
    return make_sort(lefttree, numsortkeys,
                     sortColIdx, sortOperators,
                     collations, nullsFirst);
}

References make_sort(), and prepare_sort_from_pathkeys().

Referenced by create_mergejoin_plan(), and create_sort_plan().

make_sort_from_sortclauses()

Sort* make_sort_from_sortclauses	(	List *	sortcls,
		Plan *	lefttree
	)

Definition at line 6410 of file createplan.c.

{
    List       *sub_tlist = lefttree->targetlist;
    ListCell   *l;
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;
 
    /* Convert list-ish representation to arrays wanted by executor */
    numsortkeys = list_length(sortcls);
    sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
    sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
    collations = (Oid *) palloc(numsortkeys * sizeof(Oid));
    nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool));
 
    numsortkeys = 0;
    foreach(l, sortcls)
    {
        SortGroupClause *sortcl = (SortGroupClause *) lfirst(l);
        TargetEntry *tle = get_sortgroupclause_tle(sortcl, sub_tlist);
 
        sortColIdx[numsortkeys] = tle->resno;
        sortOperators[numsortkeys] = sortcl->sortop;
        collations[numsortkeys] = exprCollation((Node *) tle->expr);
        nullsFirst[numsortkeys] = sortcl->nulls_first;
        numsortkeys++;
    }
 
    return make_sort(lefttree, numsortkeys,
                     sortColIdx, sortOperators,
                     collations, nullsFirst);
}

References TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, list_length(), make_sort(), SortGroupClause::nulls_first, palloc(), TargetEntry::resno, SortGroupClause::sortop, and Plan::targetlist.

Referenced by create_unique_plan().

make_subqueryscan()

static SubqueryScan * make_subqueryscan ( List *  qptlist, List *  qpqual, Index  scanrelid, Plan *  subplan  )

static

Definition at line 5678 of file createplan.c.

{
    SubqueryScan *node = makeNode(SubqueryScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->subplan = subplan;
    node->scanstatus = SUBQUERY_SCAN_UNKNOWN;
 
    return node;
}

References makeNode, plan, SubqueryScan::scan, Scan::scanrelid, SubqueryScan::scanstatus, SubqueryScan::subplan, and SUBQUERY_SCAN_UNKNOWN.

Referenced by create_subqueryscan_plan().

make_tablefuncscan()

static TableFuncScan * make_tablefuncscan ( List *  qptlist, List *  qpqual, Index  scanrelid, TableFunc *  tablefunc  )

static

Definition at line 5719 of file createplan.c.

{
    TableFuncScan *node = makeNode(TableFuncScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->tablefunc = tablefunc;
 
    return node;
}

References makeNode, plan, TableFuncScan::scan, Scan::scanrelid, and TableFuncScan::tablefunc.

Referenced by create_tablefuncscan_plan().

make_tidrangescan()

static TidRangeScan * make_tidrangescan ( List *  qptlist, List *  qpqual, Index  scanrelid, List *  tidrangequals  )

static

Definition at line 5659 of file createplan.c.

{
    TidRangeScan *node = makeNode(TidRangeScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->tidrangequals = tidrangequals;
 
    return node;
}

References makeNode, plan, TidRangeScan::scan, Scan::scanrelid, and TidRangeScan::tidrangequals.

Referenced by create_tidrangescan_plan().

make_tidscan()

static TidScan * make_tidscan ( List *  qptlist, List *  qpqual, Index  scanrelid, List *  tidquals  )

static

Definition at line 5640 of file createplan.c.

{
    TidScan    *node = makeNode(TidScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->tidquals = tidquals;
 
    return node;
}

References makeNode, plan, TidScan::scan, Scan::scanrelid, and TidScan::tidquals.

Referenced by create_tidscan_plan().

make_unique_from_pathkeys()

static Unique * make_unique_from_pathkeys ( Plan *  lefttree, List *  pathkeys, int  numCols  )

static

Definition at line 6743 of file createplan.c.

{
    Unique     *node = makeNode(Unique);
    Plan       *plan = &node->plan;
    int         keyno = 0;
    AttrNumber *uniqColIdx;
    Oid        *uniqOperators;
    Oid        *uniqCollations;
    ListCell   *lc;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    /*
     * Convert pathkeys list into arrays of attr indexes and equality
     * operators, as wanted by executor.  This has a lot in common with
     * prepare_sort_from_pathkeys ... maybe unify sometime?
     */
    Assert(numCols >= 0 && numCols <= list_length(pathkeys));
    uniqColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
    uniqOperators = (Oid *) palloc(sizeof(Oid) * numCols);
    uniqCollations = (Oid *) palloc(sizeof(Oid) * numCols);
 
    foreach(lc, pathkeys)
    {
        PathKey    *pathkey = (PathKey *) lfirst(lc);
        EquivalenceClass *ec = pathkey->pk_eclass;
        EquivalenceMember *em;
        TargetEntry *tle = NULL;
        Oid         pk_datatype = InvalidOid;
        Oid         eqop;
        ListCell   *j;
 
        /* Ignore pathkeys beyond the specified number of columns */
        if (keyno >= numCols)
            break;
 
        if (ec->ec_has_volatile)
        {
            /*
             * If the pathkey's EquivalenceClass is volatile, then it must
             * have come from an ORDER BY clause, and we have to match it to
             * that same targetlist entry.
             */
            if (ec->ec_sortref == 0)    /* can't happen */
                elog(ERROR, "volatile EquivalenceClass has no sortref");
            tle = get_sortgroupref_tle(ec->ec_sortref, plan->targetlist);
            Assert(tle);
            Assert(list_length(ec->ec_members) == 1);
            pk_datatype = ((EquivalenceMember *) linitial(ec->ec_members))->em_datatype;
        }
        else
        {
            /*
             * Otherwise, we can use any non-constant expression listed in the
             * pathkey's EquivalenceClass.  For now, we take the first tlist
             * item found in the EC.
             */
            foreach(j, plan->targetlist)
            {
                tle = (TargetEntry *) lfirst(j);
                em = find_ec_member_matching_expr(ec, tle->expr, NULL);
                if (em)
                {
                    /* found expr already in tlist */
                    pk_datatype = em->em_datatype;
                    break;
                }
                tle = NULL;
            }
        }
 
        if (!tle)
            elog(ERROR, "could not find pathkey item to sort");
 
        /*
         * Look up the correct equality operator from the PathKey's slightly
         * abstracted representation.
         */
        eqop = get_opfamily_member(pathkey->pk_opfamily,
                                   pk_datatype,
                                   pk_datatype,
                                   BTEqualStrategyNumber);
        if (!OidIsValid(eqop))  /* should not happen */
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 BTEqualStrategyNumber, pk_datatype, pk_datatype,
                 pathkey->pk_opfamily);
 
        uniqColIdx[keyno] = tle->resno;
        uniqOperators[keyno] = eqop;
        uniqCollations[keyno] = ec->ec_collation;
 
        keyno++;
    }
 
    node->numCols = numCols;
    node->uniqColIdx = uniqColIdx;
    node->uniqOperators = uniqOperators;
    node->uniqCollations = uniqCollations;
 
    return node;
}

References Assert, BTEqualStrategyNumber, EquivalenceClass::ec_collation, EquivalenceClass::ec_has_volatile, EquivalenceClass::ec_members, EquivalenceClass::ec_sortref, elog, EquivalenceMember::em_datatype, ERROR, TargetEntry::expr, find_ec_member_matching_expr(), get_opfamily_member(), get_sortgroupref_tle(), InvalidOid, j, lfirst, linitial, list_length(), makeNode, NIL, Unique::numCols, OidIsValid, palloc(), PathKey::pk_opfamily, Unique::plan, plan, TargetEntry::resno, and Plan::targetlist.

Referenced by create_upper_unique_plan().

make_unique_from_sortclauses()

static Unique * make_unique_from_sortclauses ( Plan *  lefttree, List *  distinctList  )

static

Definition at line 6694 of file createplan.c.

{
    Unique     *node = makeNode(Unique);
    Plan       *plan = &node->plan;
    int         numCols = list_length(distinctList);
    int         keyno = 0;
    AttrNumber *uniqColIdx;
    Oid        *uniqOperators;
    Oid        *uniqCollations;
    ListCell   *slitem;
 
    plan->targetlist = lefttree->targetlist;
    plan->qual = NIL;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
 
    /*
     * convert SortGroupClause list into arrays of attr indexes and equality
     * operators, as wanted by executor
     */
    Assert(numCols > 0);
    uniqColIdx = (AttrNumber *) palloc(sizeof(AttrNumber) * numCols);
    uniqOperators = (Oid *) palloc(sizeof(Oid) * numCols);
    uniqCollations = (Oid *) palloc(sizeof(Oid) * numCols);
 
    foreach(slitem, distinctList)
    {
        SortGroupClause *sortcl = (SortGroupClause *) lfirst(slitem);
        TargetEntry *tle = get_sortgroupclause_tle(sortcl, plan->targetlist);
 
        uniqColIdx[keyno] = tle->resno;
        uniqOperators[keyno] = sortcl->eqop;
        uniqCollations[keyno] = exprCollation((Node *) tle->expr);
        Assert(OidIsValid(uniqOperators[keyno]));
        keyno++;
    }
 
    node->numCols = numCols;
    node->uniqColIdx = uniqColIdx;
    node->uniqOperators = uniqOperators;
    node->uniqCollations = uniqCollations;
 
    return node;
}

References Assert, SortGroupClause::eqop, TargetEntry::expr, exprCollation(), get_sortgroupclause_tle(), lfirst, list_length(), makeNode, NIL, Unique::numCols, OidIsValid, palloc(), Unique::plan, plan, TargetEntry::resno, and Plan::targetlist.

Referenced by create_unique_plan().

make_valuesscan()

static ValuesScan * make_valuesscan ( List *  qptlist, List *  qpqual, Index  scanrelid, List *  values_lists  )

static

Definition at line 5738 of file createplan.c.

{
    ValuesScan *node = makeNode(ValuesScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->values_lists = values_lists;
 
    return node;
}

References makeNode, plan, ValuesScan::scan, Scan::scanrelid, and ValuesScan::values_lists.

Referenced by create_valuesscan_plan().

make_windowagg()

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

Definition at line 6622 of file createplan.c.

{
    WindowAgg  *node = makeNode(WindowAgg);
    Plan       *plan = &node->plan;
 
    node->winref = winref;
    node->partNumCols = partNumCols;
    node->partColIdx = partColIdx;
    node->partOperators = partOperators;
    node->partCollations = partCollations;
    node->ordNumCols = ordNumCols;
    node->ordColIdx = ordColIdx;
    node->ordOperators = ordOperators;
    node->ordCollations = ordCollations;
    node->frameOptions = frameOptions;
    node->startOffset = startOffset;
    node->endOffset = endOffset;
    node->runCondition = runCondition;
    /* a duplicate of the above for EXPLAIN */
    node->runConditionOrig = runCondition;
    node->startInRangeFunc = startInRangeFunc;
    node->endInRangeFunc = endInRangeFunc;
    node->inRangeColl = inRangeColl;
    node->inRangeAsc = inRangeAsc;
    node->inRangeNullsFirst = inRangeNullsFirst;
    node->topWindow = topWindow;
 
    plan->targetlist = tlist;
    plan->lefttree = lefttree;
    plan->righttree = NULL;
    plan->qual = qual;
 
    return node;
}

References WindowAgg::endInRangeFunc, WindowAgg::endOffset, WindowAgg::frameOptions, WindowAgg::inRangeAsc, WindowAgg::inRangeColl, WindowAgg::inRangeNullsFirst, makeNode, WindowAgg::ordNumCols, WindowAgg::partNumCols, WindowAgg::plan, plan, WindowAgg::runCondition, WindowAgg::runConditionOrig, WindowAgg::startInRangeFunc, WindowAgg::startOffset, WindowAgg::topWindow, and WindowAgg::winref.

Referenced by create_windowagg_plan().

make_worktablescan()

static WorkTableScan * make_worktablescan ( List *  qptlist, List *  qpqual, Index  scanrelid, int  wtParam  )

static

Definition at line 5798 of file createplan.c.

{
    WorkTableScan *node = makeNode(WorkTableScan);
    Plan       *plan = &node->scan.plan;
 
    plan->targetlist = qptlist;
    plan->qual = qpqual;
    plan->lefttree = NULL;
    plan->righttree = NULL;
    node->scan.scanrelid = scanrelid;
    node->wtParam = wtParam;
 
    return node;
}

References makeNode, plan, WorkTableScan::scan, Scan::scanrelid, and WorkTableScan::wtParam.

Referenced by create_worktablescan_plan().

mark_async_capable_plan()

static bool mark_async_capable_plan ( Plan *  plan, Path *  path  )

static

Definition at line 1140 of file createplan.c.

{
    switch (nodeTag(path))
    {
        case T_SubqueryScanPath:
            {
                SubqueryScan *scan_plan = (SubqueryScan *) plan;
 
                /*
                 * If the generated plan node includes a gating Result node,
                 * we can't execute it asynchronously.
                 */
                if (IsA(plan, Result))
                    return false;
 
                /*
                 * If a SubqueryScan node atop of an async-capable plan node
                 * is deletable, consider it as async-capable.
                 */
                if (trivial_subqueryscan(scan_plan) &&
                    mark_async_capable_plan(scan_plan->subplan,
                                            ((SubqueryScanPath *) path)->subpath))
                    break;
                return false;
            }
        case T_ForeignPath:
            {
                FdwRoutine *fdwroutine = path->parent->fdwroutine;
 
                /*
                 * If the generated plan node includes a gating Result node,
                 * we can't execute it asynchronously.
                 */
                if (IsA(plan, Result))
                    return false;
 
                Assert(fdwroutine != NULL);
                if (fdwroutine->IsForeignPathAsyncCapable != NULL &&
                    fdwroutine->IsForeignPathAsyncCapable((ForeignPath *) path))
                    break;
                return false;
            }
        case T_ProjectionPath:
 
            /*
             * If the generated plan node includes a Result node for the
             * projection, we can't execute it asynchronously.
             */
            if (IsA(plan, Result))
                return false;
 
            /*
             * create_projection_plan() would have pulled up the subplan, so
             * check the capability using the subpath.
             */
            if (mark_async_capable_plan(plan,
                                        ((ProjectionPath *) path)->subpath))
                return true;
            return false;
        default:
            return false;
    }
 
    plan->async_capable = true;
 
    return true;
}

References Assert, IsA, FdwRoutine::IsForeignPathAsyncCapable, nodeTag, plan, subpath(), SubqueryScan::subplan, and trivial_subqueryscan().

Referenced by create_append_plan().

materialize_finished_plan()

Plan* materialize_finished_plan

(

Plan *

subplan

)

Definition at line 6522 of file createplan.c.

{
    Plan       *matplan;
    Path        matpath;        /* dummy for result of cost_material */
    Cost        initplan_cost;
    bool        unsafe_initplans;
 
    matplan = (Plan *) make_material(subplan);
 
    /*
     * XXX horrid kluge: if there are any initPlans attached to the subplan,
     * move them up to the Material node, which is now effectively the top
     * plan node in its query level.  This prevents failure in
     * SS_finalize_plan(), which see for comments.
     */
    matplan->initPlan = subplan->initPlan;
    subplan->initPlan = NIL;
 
    /* Move the initplans' cost delta, as well */
    SS_compute_initplan_cost(matplan->initPlan,
                             &initplan_cost, &unsafe_initplans);
    subplan->startup_cost -= initplan_cost;
    subplan->total_cost -= initplan_cost;
 
    /* Set cost data */
    cost_material(&matpath,
                  subplan->startup_cost,
                  subplan->total_cost,
                  subplan->plan_rows,
                  subplan->plan_width);
    matplan->startup_cost = matpath.startup_cost + initplan_cost;
    matplan->total_cost = matpath.total_cost + initplan_cost;
    matplan->plan_rows = subplan->plan_rows;
    matplan->plan_width = subplan->plan_width;
    matplan->parallel_aware = false;
    matplan->parallel_safe = subplan->parallel_safe;
 
    return matplan;
}

References cost_material(), Plan::initPlan, make_material(), NIL, Plan::parallel_aware, Plan::parallel_safe, Plan::plan_rows, Plan::plan_width, SS_compute_initplan_cost(), Path::startup_cost, Plan::startup_cost, Path::total_cost, and Plan::total_cost.

Referenced by build_subplan(), and standard_planner().

order_qual_clauses()

static List * order_qual_clauses ( PlannerInfo *  root, List *  clauses  )

static

Definition at line 5310 of file createplan.c.

{
    typedef struct
    {
        Node       *clause;
        Cost        cost;
        Index       security_level;
    } QualItem;
    int         nitems = list_length(clauses);
    QualItem   *items;
    ListCell   *lc;
    int         i;
    List       *result;
 
    /* No need to work hard for 0 or 1 clause */
    if (nitems <= 1)
        return clauses;
 
    /*
     * Collect the items and costs into an array.  This is to avoid repeated
     * cost_qual_eval work if the inputs aren't RestrictInfos.
     */
    items = (QualItem *) palloc(nitems * sizeof(QualItem));
    i = 0;
    foreach(lc, clauses)
    {
        Node       *clause = (Node *) lfirst(lc);
        QualCost    qcost;
 
        cost_qual_eval_node(&qcost, clause, root);
        items[i].clause = clause;
        items[i].cost = qcost.per_tuple;
        if (IsA(clause, RestrictInfo))
        {
            RestrictInfo *rinfo = (RestrictInfo *) clause;
 
            /*
             * If a clause is leakproof, it doesn't have to be constrained by
             * its nominal security level.  If it's also reasonably cheap
             * (here defined as 10X cpu_operator_cost), pretend it has
             * security_level 0, which will allow it to go in front of
             * more-expensive quals of lower security levels.  Of course, that
             * will also force it to go in front of cheaper quals of its own
             * security level, which is not so great, but we can alleviate
             * that risk by applying the cost limit cutoff.
             */
            if (rinfo->leakproof && items[i].cost < 10 * cpu_operator_cost)
                items[i].security_level = 0;
            else
                items[i].security_level = rinfo->security_level;
        }
        else
            items[i].security_level = 0;
        i++;
    }
 
    /*
     * Sort.  We don't use qsort() because it's not guaranteed stable for
     * equal keys.  The expected number of entries is small enough that a
     * simple insertion sort should be good enough.
     */
    for (i = 1; i < nitems; i++)
    {
        QualItem    newitem = items[i];
        int         j;
 
        /* insert newitem into the already-sorted subarray */
        for (j = i; j > 0; j--)
        {
            QualItem   *olditem = &items[j - 1];
 
            if (newitem.security_level > olditem->security_level ||
                (newitem.security_level == olditem->security_level &&
                 newitem.cost >= olditem->cost))
                break;
            items[j] = *olditem;
        }
        items[j] = newitem;
    }
 
    /* Convert back to a list */
    result = NIL;
    for (i = 0; i < nitems; i++)
        result = lappend(result, items[i].clause);
 
    return result;
}

References cost_qual_eval_node(), cpu_operator_cost, i, IsA, items, j, lappend(), lfirst, list_length(), NIL, nitems, palloc(), QualCost::per_tuple, root, and RestrictInfo::security_level.

Referenced by create_agg_plan(), create_bitmap_scan_plan(), create_ctescan_plan(), create_customscan_plan(), create_foreignscan_plan(), create_functionscan_plan(), create_group_plan(), create_group_result_plan(), create_hashjoin_plan(), create_indexscan_plan(), create_mergejoin_plan(), create_namedtuplestorescan_plan(), create_nestloop_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(), and get_gating_quals().

prepare_sort_from_pathkeys()

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

Definition at line 6159 of file createplan.c.

{
    List       *tlist = lefttree->targetlist;
    ListCell   *i;
    int         numsortkeys;
    AttrNumber *sortColIdx;
    Oid        *sortOperators;
    Oid        *collations;
    bool       *nullsFirst;
 
    /*
     * We will need at most list_length(pathkeys) sort columns; possibly less
     */
    numsortkeys = list_length(pathkeys);
    sortColIdx = (AttrNumber *) palloc(numsortkeys * sizeof(AttrNumber));
    sortOperators = (Oid *) palloc(numsortkeys * sizeof(Oid));
    collations = (Oid *) palloc(numsortkeys * sizeof(Oid));
    nullsFirst = (bool *) palloc(numsortkeys * sizeof(bool));
 
    numsortkeys = 0;
 
    foreach(i, pathkeys)
    {
        PathKey    *pathkey = (PathKey *) lfirst(i);
        EquivalenceClass *ec = pathkey->pk_eclass;
        EquivalenceMember *em;
        TargetEntry *tle = NULL;
        Oid         pk_datatype = InvalidOid;
        Oid         sortop;
        ListCell   *j;
 
        if (ec->ec_has_volatile)
        {
            /*
             * If the pathkey's EquivalenceClass is volatile, then it must
             * have come from an ORDER BY clause, and we have to match it to
             * that same targetlist entry.
             */
            if (ec->ec_sortref == 0)    /* can't happen */
                elog(ERROR, "volatile EquivalenceClass has no sortref");
            tle = get_sortgroupref_tle(ec->ec_sortref, tlist);
            Assert(tle);
            Assert(list_length(ec->ec_members) == 1);
            pk_datatype = ((EquivalenceMember *) linitial(ec->ec_members))->em_datatype;
        }
        else if (reqColIdx != NULL)
        {
            /*
             * If we are given a sort column number to match, only consider
             * the single TLE at that position.  It's possible that there is
             * no such TLE, in which case fall through and generate a resjunk
             * targetentry (we assume this must have happened in the parent
             * plan as well).  If there is a TLE but it doesn't match the
             * pathkey's EC, we do the same, which is probably the wrong thing
             * but we'll leave it to caller to complain about the mismatch.
             */
            tle = get_tle_by_resno(tlist, reqColIdx[numsortkeys]);
            if (tle)
            {
                em = find_ec_member_matching_expr(ec, tle->expr, relids);
                if (em)
                {
                    /* found expr at right place in tlist */
                    pk_datatype = em->em_datatype;
                }
                else
                    tle = NULL;
            }
        }
        else
        {
            /*
             * Otherwise, we can sort by any non-constant expression listed in
             * the pathkey's EquivalenceClass.  For now, we take the first
             * tlist item found in the EC. If there's no match, we'll generate
             * a resjunk entry using the first EC member that is an expression
             * in the input's vars.
             *
             * XXX if we have a choice, is there any way of figuring out which
             * might be cheapest to execute?  (For example, int4lt is likely
             * much cheaper to execute than numericlt, but both might appear
             * in the same equivalence class...)  Not clear that we ever will
             * have an interesting choice in practice, so it may not matter.
             */
            foreach(j, tlist)
            {
                tle = (TargetEntry *) lfirst(j);
                em = find_ec_member_matching_expr(ec, tle->expr, relids);
                if (em)
                {
                    /* found expr already in tlist */
                    pk_datatype = em->em_datatype;
                    break;
                }
                tle = NULL;
            }
        }
 
        if (!tle)
        {
            /*
             * No matching tlist item; look for a computable expression.
             */
            em = find_computable_ec_member(NULL, ec, tlist, relids, false);
            if (!em)
                elog(ERROR, "could not find pathkey item to sort");
            pk_datatype = em->em_datatype;
 
            /*
             * Do we need to insert a Result node?
             */
            if (!adjust_tlist_in_place &&
                !is_projection_capable_plan(lefttree))
            {
                /* copy needed so we don't modify input's tlist below */
                tlist = copyObject(tlist);
                lefttree = inject_projection_plan(lefttree, tlist,
                                                  lefttree->parallel_safe);
            }
 
            /* Don't bother testing is_projection_capable_plan again */
            adjust_tlist_in_place = true;
 
            /*
             * Add resjunk entry to input's tlist
             */
            tle = makeTargetEntry(copyObject(em->em_expr),
                                  list_length(tlist) + 1,
                                  NULL,
                                  true);
            tlist = lappend(tlist, tle);
            lefttree->targetlist = tlist;   /* just in case NIL before */
        }
 
        /*
         * Look up the correct sort operator from the PathKey's slightly
         * abstracted representation.
         */
        sortop = get_opfamily_member(pathkey->pk_opfamily,
                                     pk_datatype,
                                     pk_datatype,
                                     pathkey->pk_strategy);
        if (!OidIsValid(sortop))    /* should not happen */
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 pathkey->pk_strategy, pk_datatype, pk_datatype,
                 pathkey->pk_opfamily);
 
        /* Add the column to the sort arrays */
        sortColIdx[numsortkeys] = tle->resno;
        sortOperators[numsortkeys] = sortop;
        collations[numsortkeys] = ec->ec_collation;
        nullsFirst[numsortkeys] = pathkey->pk_nulls_first;
        numsortkeys++;
    }
 
    /* Return results */
    *p_numsortkeys = numsortkeys;
    *p_sortColIdx = sortColIdx;
    *p_sortOperators = sortOperators;
    *p_collations = collations;
    *p_nullsFirst = nullsFirst;
 
    return lefttree;
}

References Assert, copyObject, EquivalenceClass::ec_collation, EquivalenceClass::ec_has_volatile, EquivalenceClass::ec_members, EquivalenceClass::ec_sortref, elog, EquivalenceMember::em_datatype, EquivalenceMember::em_expr, ERROR, TargetEntry::expr, find_computable_ec_member(), find_ec_member_matching_expr(), get_opfamily_member(), get_sortgroupref_tle(), get_tle_by_resno(), i, inject_projection_plan(), InvalidOid, is_projection_capable_plan(), j, lappend(), lfirst, linitial, list_length(), makeTargetEntry(), OidIsValid, palloc(), Plan::parallel_safe, PathKey::pk_nulls_first, PathKey::pk_opfamily, PathKey::pk_strategy, TargetEntry::resno, and Plan::targetlist.

Referenced by create_append_plan(), create_gather_merge_plan(), create_merge_append_plan(), make_incrementalsort_from_pathkeys(), and make_sort_from_pathkeys().

remap_groupColIdx()

static AttrNumber* remap_groupColIdx ( PlannerInfo *  root, List *  groupClause  )

static

Definition at line 2349 of file createplan.c.

{
    AttrNumber *grouping_map = root->grouping_map;
    AttrNumber *new_grpColIdx;
    ListCell   *lc;
    int         i;
 
    Assert(grouping_map);
 
    new_grpColIdx = palloc0(sizeof(AttrNumber) * list_length(groupClause));
 
    i = 0;
    foreach(lc, groupClause)
    {
        SortGroupClause *clause = lfirst(lc);
 
        new_grpColIdx[i++] = grouping_map[clause->tleSortGroupRef];
    }
 
    return new_grpColIdx;
}

References Assert, i, lfirst, list_length(), palloc0(), root, and SortGroupClause::tleSortGroupRef.

Referenced by create_groupingsets_plan().

replace_nestloop_params()

static Node * replace_nestloop_params ( PlannerInfo *  root, Node *  expr  )

static

Definition at line 4930 of file createplan.c.

{
    /* No setup needed for tree walk, so away we go */
    return replace_nestloop_params_mutator(expr, root);
}

References replace_nestloop_params_mutator(), and root.

Referenced by build_path_tlist(), create_append_plan(), create_bitmap_scan_plan(), create_ctescan_plan(), create_customscan_plan(), create_foreignscan_plan(), create_functionscan_plan(), create_hashjoin_plan(), create_indexscan_plan(), create_memoize_plan(), create_mergejoin_plan(), create_namedtuplestorescan_plan(), create_nestloop_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(), and fix_indexqual_clause().

replace_nestloop_params_mutator()

static Node * replace_nestloop_params_mutator ( Node *  node, PlannerInfo *  root  )

static

Definition at line 4937 of file createplan.c.

{
    if (node == NULL)
        return NULL;
    if (IsA(node, Var))
    {
        Var        *var = (Var *) node;
 
        /* Upper-level Vars should be long gone at this point */
        Assert(var->varlevelsup == 0);
        /* If not to be replaced, we can just return the Var unmodified */
        if (IS_SPECIAL_VARNO(var->varno) ||
            !bms_is_member(var->varno, root->curOuterRels))
            return node;
        /* Replace the Var with a nestloop Param */
        return (Node *) replace_nestloop_param_var(root, var);
    }
    if (IsA(node, PlaceHolderVar))
    {
        PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
        /* Upper-level PlaceHolderVars should be long gone at this point */
        Assert(phv->phlevelsup == 0);
 
        /* Check whether we need to replace the PHV */
        if (!bms_is_subset(find_placeholder_info(root, phv)->ph_eval_at,
                           root->curOuterRels))
        {
            /*
             * We can't replace the whole PHV, but we might still need to
             * replace Vars or PHVs within its expression, in case it ends up
             * actually getting evaluated here.  (It might get evaluated in
             * this plan node, or some child node; in the latter case we don't
             * really need to process the expression here, but we haven't got
             * enough info to tell if that's the case.)  Flat-copy the PHV
             * node and then recurse on its expression.
             *
             * Note that after doing this, we might have different
             * representations of the contents of the same PHV in different
             * parts of the plan tree.  This is OK because equal() will just
             * match on phid/phlevelsup, so setrefs.c will still recognize an
             * upper-level reference to a lower-level copy of the same PHV.
             */
            PlaceHolderVar *newphv = makeNode(PlaceHolderVar);
 
            memcpy(newphv, phv, sizeof(PlaceHolderVar));
            newphv->phexpr = (Expr *)
                replace_nestloop_params_mutator((Node *) phv->phexpr,
                                                root);
            return (Node *) newphv;
        }
        /* Replace the PlaceHolderVar with a nestloop Param */
        return (Node *) replace_nestloop_param_placeholdervar(root, phv);
    }
    return expression_tree_mutator(node,
                                   replace_nestloop_params_mutator,
                                   (void *) root);
}

References Assert, bms_is_member(), bms_is_subset(), expression_tree_mutator, find_placeholder_info(), IS_SPECIAL_VARNO, IsA, makeNode, PlaceHolderVar::phlevelsup, replace_nestloop_param_placeholdervar(), replace_nestloop_param_var(), root, Var::varlevelsup, and Var::varno.

Referenced by replace_nestloop_params().

use_physical_tlist()

static bool use_physical_tlist ( PlannerInfo *  root, Path *  path, int  flags  )

static

Definition at line 865 of file createplan.c.

{
    RelOptInfo *rel = path->parent;
    int         i;
    ListCell   *lc;
 
    /*
     * Forget it if either exact tlist or small tlist is demanded.
     */
    if (flags & (CP_EXACT_TLIST | CP_SMALL_TLIST))
        return false;
 
    /*
     * We can do this for real relation scans, subquery scans, function scans,
     * tablefunc scans, values scans, and CTE scans (but not for, eg, joins).
     */
    if (rel->rtekind != RTE_RELATION &&
        rel->rtekind != RTE_SUBQUERY &&
        rel->rtekind != RTE_FUNCTION &&
        rel->rtekind != RTE_TABLEFUNC &&
        rel->rtekind != RTE_VALUES &&
        rel->rtekind != RTE_CTE)
        return false;
 
    /*
     * Can't do it with inheritance cases either (mainly because Append
     * doesn't project; this test may be unnecessary now that
     * create_append_plan instructs its children to return an exact tlist).
     */
    if (rel->reloptkind != RELOPT_BASEREL)
        return false;
 
    /*
     * Also, don't do it to a CustomPath; the premise that we're extracting
     * columns from a simple physical tuple is unlikely to hold for those.
     * (When it does make sense, the custom path creator can set up the path's
     * pathtarget that way.)
     */
    if (IsA(path, CustomPath))
        return false;
 
    /*
     * If a bitmap scan's tlist is empty, keep it as-is.  This may allow the
     * executor to skip heap page fetches, and in any case, the benefit of
     * using a physical tlist instead would be minimal.
     */
    if (IsA(path, BitmapHeapPath) &&
        path->pathtarget->exprs == NIL)
        return false;
 
    /*
     * Can't do it if any system columns or whole-row Vars are requested.
     * (This could possibly be fixed but would take some fragile assumptions
     * in setrefs.c, I think.)
     */
    for (i = rel->min_attr; i <= 0; i++)
    {
        if (!bms_is_empty(rel->attr_needed[i - rel->min_attr]))
            return false;
    }
 
    /*
     * Can't do it if the rel is required to emit any placeholder expressions,
     * either.
     */
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = (PlaceHolderInfo *) lfirst(lc);
 
        if (bms_nonempty_difference(phinfo->ph_needed, rel->relids) &&
            bms_is_subset(phinfo->ph_eval_at, rel->relids))
            return false;
    }
 
    /*
     * For an index-only scan, the "physical tlist" is the index's indextlist.
     * We can only return that without a projection if all the index's columns
     * are returnable.
     */
    if (path->pathtype == T_IndexOnlyScan)
    {
        IndexOptInfo *indexinfo = ((IndexPath *) path)->indexinfo;
 
        for (i = 0; i < indexinfo->ncolumns; i++)
        {
            if (!indexinfo->canreturn[i])
                return false;
        }
    }
 
    /*
     * Also, can't do it if CP_LABEL_TLIST is specified and path is requested
     * to emit any sort/group columns that are not simple Vars.  (If they are
     * simple Vars, they should appear in the physical tlist, and
     * apply_pathtarget_labeling_to_tlist will take care of getting them
     * labeled again.)  We also have to check that no two sort/group columns
     * are the same Var, else that element of the physical tlist would need
     * conflicting ressortgroupref labels.
     */
    if ((flags & CP_LABEL_TLIST) && path->pathtarget->sortgrouprefs)
    {
        Bitmapset  *sortgroupatts = NULL;
 
        i = 0;
        foreach(lc, path->pathtarget->exprs)
        {
            Expr       *expr = (Expr *) lfirst(lc);
 
            if (path->pathtarget->sortgrouprefs[i])
            {
                if (expr && IsA(expr, Var))
                {
                    int         attno = ((Var *) expr)->varattno;
 
                    attno -= FirstLowInvalidHeapAttributeNumber;
                    if (bms_is_member(attno, sortgroupatts))
                        return false;
                    sortgroupatts = bms_add_member(sortgroupatts, attno);
                }
                else
                    return false;
            }
            i++;
        }
    }
 
    return true;
}

References bms_add_member(), bms_is_empty, bms_is_member(), bms_is_subset(), bms_nonempty_difference(), CP_EXACT_TLIST, CP_LABEL_TLIST, CP_SMALL_TLIST, FirstLowInvalidHeapAttributeNumber, i, IsA, lfirst, RelOptInfo::min_attr, IndexOptInfo::ncolumns, NIL, Path::pathtype, PlaceHolderInfo::ph_eval_at, PlaceHolderInfo::ph_needed, RelOptInfo::relids, RELOPT_BASEREL, RelOptInfo::reloptkind, root, RTE_CTE, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, and RelOptInfo::rtekind.

Referenced by create_projection_plan(), and create_scan_plan().