pathnode.h File Reference

#include "nodes/bitmapset.h"
#include "nodes/pathnodes.h"

Include dependency graph for pathnode.h:

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

Go to the source code of this file.

Functions
int	compare_path_costs (Path *path1, Path *path2, CostSelector criterion)
int	compare_fractional_path_costs (Path *path1, Path *path2, double fraction)
void	set_cheapest (RelOptInfo *parent_rel)
void	add_path (RelOptInfo *parent_rel, Path *new_path)
bool	add_path_precheck (RelOptInfo *parent_rel, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer)
void	add_partial_path (RelOptInfo *parent_rel, Path *new_path)
bool	add_partial_path_precheck (RelOptInfo *parent_rel, int disabled_nodes, Cost total_cost, List *pathkeys)
Path *	create_seqscan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer, int parallel_workers)
Path *	create_samplescan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
IndexPath *	create_index_path (PlannerInfo *root, IndexOptInfo *index, List *indexclauses, List *indexorderbys, List *indexorderbycols, List *pathkeys, ScanDirection indexscandir, bool indexonly, Relids required_outer, double loop_count, bool partial_path)
BitmapHeapPath *	create_bitmap_heap_path (PlannerInfo *root, RelOptInfo *rel, Path *bitmapqual, Relids required_outer, double loop_count, int parallel_degree)
BitmapAndPath *	create_bitmap_and_path (PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
BitmapOrPath *	create_bitmap_or_path (PlannerInfo *root, RelOptInfo *rel, List *bitmapquals)
TidPath *	create_tidscan_path (PlannerInfo *root, RelOptInfo *rel, List *tidquals, Relids required_outer)
TidRangePath *	create_tidrangescan_path (PlannerInfo *root, RelOptInfo *rel, List *tidrangequals, Relids required_outer)
AppendPath *	create_append_path (PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *partial_subpaths, List *pathkeys, Relids required_outer, int parallel_workers, bool parallel_aware, double rows)
MergeAppendPath *	create_merge_append_path (PlannerInfo *root, RelOptInfo *rel, List *subpaths, List *pathkeys, Relids required_outer)
GroupResultPath *	create_group_result_path (PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *havingqual)
MaterialPath *	create_material_path (RelOptInfo *rel, Path *subpath)
MemoizePath *	create_memoize_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *param_exprs, List *hash_operators, bool singlerow, bool binary_mode, double calls)
UniquePath *	create_unique_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, SpecialJoinInfo *sjinfo)
GatherPath *	create_gather_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, Relids required_outer, double *rows)
GatherMergePath *	create_gather_merge_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *pathkeys, Relids required_outer, double *rows)
SubqueryScanPath *	create_subqueryscan_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, bool trivial_pathtarget, List *pathkeys, Relids required_outer)
Path *	create_functionscan_path (PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Path *	create_valuesscan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path *	create_tablefuncscan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path *	create_ctescan_path (PlannerInfo *root, RelOptInfo *rel, List *pathkeys, Relids required_outer)
Path *	create_namedtuplestorescan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path *	create_resultscan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
Path *	create_worktablescan_path (PlannerInfo *root, RelOptInfo *rel, Relids required_outer)
ForeignPath *	create_foreignscan_path (PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
ForeignPath *	create_foreign_join_path (PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
ForeignPath *	create_foreign_upper_path (PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
Relids	calc_nestloop_required_outer (Relids outerrelids, Relids outer_paramrels, Relids innerrelids, Relids inner_paramrels)
Relids	calc_non_nestloop_required_outer (Path *outer_path, Path *inner_path)
NestPath *	create_nestloop_path (PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, List *restrict_clauses, List *pathkeys, Relids required_outer)
MergePath *	create_mergejoin_path (PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, List *restrict_clauses, List *pathkeys, Relids required_outer, List *mergeclauses, List *outersortkeys, List *innersortkeys, int outer_presorted_keys)
HashPath *	create_hashjoin_path (PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, JoinCostWorkspace *workspace, JoinPathExtraData *extra, Path *outer_path, Path *inner_path, bool parallel_hash, List *restrict_clauses, Relids required_outer, List *hashclauses)
ProjectionPath *	create_projection_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Path *	apply_projection_to_path (PlannerInfo *root, RelOptInfo *rel, Path *path, PathTarget *target)
ProjectSetPath *	create_set_projection_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
SortPath *	create_sort_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
IncrementalSortPath *	create_incremental_sort_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, int presorted_keys, double limit_tuples)
GroupPath *	create_group_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *groupClause, List *qual, double numGroups)
UpperUniquePath *	create_upper_unique_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, int numCols, double numGroups)
AggPath *	create_agg_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, AggStrategy aggstrategy, AggSplit aggsplit, List *groupClause, List *qual, const AggClauseCosts *aggcosts, double numGroups)
GroupingSetsPath *	create_groupingsets_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *having_qual, AggStrategy aggstrategy, List *rollups, const AggClauseCosts *agg_costs)
MinMaxAggPath *	create_minmaxagg_path (PlannerInfo *root, RelOptInfo *rel, PathTarget *target, List *mmaggregates, List *quals)
WindowAggPath *	create_windowagg_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target, List *windowFuncs, List *runCondition, WindowClause *winclause, List *qual, bool topwindow)
SetOpPath *	create_setop_path (PlannerInfo *root, RelOptInfo *rel, Path *leftpath, Path *rightpath, SetOpCmd cmd, SetOpStrategy strategy, List *groupList, double numGroups, double outputRows)
RecursiveUnionPath *	create_recursiveunion_path (PlannerInfo *root, RelOptInfo *rel, Path *leftpath, Path *rightpath, PathTarget *target, List *distinctList, int wtParam, double numGroups)
LockRowsPath *	create_lockrows_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *rowMarks, int epqParam)
ModifyTablePath *	create_modifytable_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, 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)
LimitPath *	create_limit_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, Node *limitOffset, Node *limitCount, LimitOption limitOption, int64 offset_est, int64 count_est)
void	adjust_limit_rows_costs (double *rows, Cost *startup_cost, Cost *total_cost, int64 offset_est, int64 count_est)
Path *	reparameterize_path (PlannerInfo *root, Path *path, Relids required_outer, double loop_count)
Path *	reparameterize_path_by_child (PlannerInfo *root, Path *path, RelOptInfo *child_rel)
bool	path_is_reparameterizable_by_child (Path *path, RelOptInfo *child_rel)
void	setup_simple_rel_arrays (PlannerInfo *root)
void	expand_planner_arrays (PlannerInfo *root, int add_size)
RelOptInfo *	build_simple_rel (PlannerInfo *root, int relid, RelOptInfo *parent)
RelOptInfo *	find_base_rel (PlannerInfo *root, int relid)
RelOptInfo *	find_base_rel_noerr (PlannerInfo *root, int relid)
RelOptInfo *	find_base_rel_ignore_join (PlannerInfo *root, int relid)
RelOptInfo *	find_join_rel (PlannerInfo *root, Relids relids)
RelOptInfo *	build_join_rel (PlannerInfo *root, Relids joinrelids, RelOptInfo *outer_rel, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo, List *pushed_down_joins, List **restrictlist_ptr)
Relids	min_join_parameterization (PlannerInfo *root, Relids joinrelids, RelOptInfo *outer_rel, RelOptInfo *inner_rel)
RelOptInfo *	fetch_upper_rel (PlannerInfo *root, UpperRelationKind kind, Relids relids)
Relids	find_childrel_parents (PlannerInfo *root, RelOptInfo *rel)
ParamPathInfo *	get_baserel_parampathinfo (PlannerInfo *root, RelOptInfo *baserel, Relids required_outer)
ParamPathInfo *	get_joinrel_parampathinfo (PlannerInfo *root, RelOptInfo *joinrel, Path *outer_path, Path *inner_path, SpecialJoinInfo *sjinfo, Relids required_outer, List **restrict_clauses)
ParamPathInfo *	get_appendrel_parampathinfo (RelOptInfo *appendrel, Relids required_outer)
ParamPathInfo *	find_param_path_info (RelOptInfo *rel, Relids required_outer)
Bitmapset *	get_param_path_clause_serials (Path *path)
RelOptInfo *	build_child_join_rel (PlannerInfo *root, RelOptInfo *outer_rel, RelOptInfo *inner_rel, RelOptInfo *parent_joinrel, List *restrictlist, SpecialJoinInfo *sjinfo, int nappinfos, AppendRelInfo **appinfos)

Function Documentation

add_partial_path()

void add_partial_path	(	RelOptInfo *	parent_rel,
		Path *	new_path
	)

Definition at line 795 of file pathnode.c.

{
    bool        accept_new = true;  /* unless we find a superior old path */
    int         insert_at = 0;  /* where to insert new item */
    ListCell   *p1;
 
    /* Check for query cancel. */
    CHECK_FOR_INTERRUPTS();
 
    /* Path to be added must be parallel safe. */
    Assert(new_path->parallel_safe);
 
    /* Relation should be OK for parallelism, too. */
    Assert(parent_rel->consider_parallel);
 
    /*
     * As in add_path, throw out any paths which are dominated by the new
     * path, but throw out the new path if some existing path dominates it.
     */
    foreach(p1, parent_rel->partial_pathlist)
    {
        Path       *old_path = (Path *) lfirst(p1);
        bool        remove_old = false; /* unless new proves superior */
        PathKeysComparison keyscmp;
 
        /* Compare pathkeys. */
        keyscmp = compare_pathkeys(new_path->pathkeys, old_path->pathkeys);
 
        /* Unless pathkeys are incompatible, keep just one of the two paths. */
        if (keyscmp != PATHKEYS_DIFFERENT)
        {
            if (unlikely(new_path->disabled_nodes != old_path->disabled_nodes))
            {
                if (new_path->disabled_nodes > old_path->disabled_nodes)
                    accept_new = false;
                else
                    remove_old = true;
            }
            else if (new_path->total_cost > old_path->total_cost
                     * STD_FUZZ_FACTOR)
            {
                /* New path costs more; keep it only if pathkeys are better. */
                if (keyscmp != PATHKEYS_BETTER1)
                    accept_new = false;
            }
            else if (old_path->total_cost > new_path->total_cost
                     * STD_FUZZ_FACTOR)
            {
                /* Old path costs more; keep it only if pathkeys are better. */
                if (keyscmp != PATHKEYS_BETTER2)
                    remove_old = true;
            }
            else if (keyscmp == PATHKEYS_BETTER1)
            {
                /* Costs are about the same, new path has better pathkeys. */
                remove_old = true;
            }
            else if (keyscmp == PATHKEYS_BETTER2)
            {
                /* Costs are about the same, old path has better pathkeys. */
                accept_new = false;
            }
            else if (old_path->total_cost > new_path->total_cost * 1.0000000001)
            {
                /* Pathkeys are the same, and the old path costs more. */
                remove_old = true;
            }
            else
            {
                /*
                 * Pathkeys are the same, and new path isn't materially
                 * cheaper.
                 */
                accept_new = false;
            }
        }
 
        /*
         * Remove current element from partial_pathlist if dominated by new.
         */
        if (remove_old)
        {
            parent_rel->partial_pathlist =
                foreach_delete_current(parent_rel->partial_pathlist, p1);
            pfree(old_path);
        }
        else
        {
            /* new belongs after this old path if it has cost >= old's */
            if (new_path->total_cost >= old_path->total_cost)
                insert_at = foreach_current_index(p1) + 1;
        }
 
        /*
         * If we found an old path that dominates new_path, we can quit
         * scanning the partial_pathlist; we will not add new_path, and we
         * assume new_path cannot dominate any later path.
         */
        if (!accept_new)
            break;
    }
 
    if (accept_new)
    {
        /* Accept the new path: insert it at proper place */
        parent_rel->partial_pathlist =
            list_insert_nth(parent_rel->partial_pathlist, insert_at, new_path);
    }
    else
    {
        /* Reject and recycle the new path */
        pfree(new_path);
    }
}

References Assert(), CHECK_FOR_INTERRUPTS, compare_pathkeys(), RelOptInfo::consider_parallel, Path::disabled_nodes, foreach_current_index, foreach_delete_current, lfirst, list_insert_nth(), Path::parallel_safe, RelOptInfo::partial_pathlist, Path::pathkeys, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, pfree(), STD_FUZZ_FACTOR, Path::total_cost, and unlikely.

Referenced by add_paths_to_append_rel(), build_index_paths(), build_setop_child_paths(), create_partial_bitmap_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), create_plain_partial_paths(), grouping_planner(), set_subquery_pathlist(), try_partial_hashjoin_path(), try_partial_mergejoin_path(), and try_partial_nestloop_path().

add_partial_path_precheck()

bool add_partial_path_precheck	(	RelOptInfo *	parent_rel,
		int	disabled_nodes,
		Cost	total_cost,
		List *	pathkeys
	)

Definition at line 921 of file pathnode.c.

{
    ListCell   *p1;
 
    /*
     * Our goal here is twofold.  First, we want to find out whether this path
     * is clearly inferior to some existing partial path.  If so, we want to
     * reject it immediately.  Second, we want to find out whether this path
     * is clearly superior to some existing partial path -- at least, modulo
     * final cost computations.  If so, we definitely want to consider it.
     *
     * Unlike add_path(), we always compare pathkeys here.  This is because we
     * expect partial_pathlist to be very short, and getting a definitive
     * answer at this stage avoids the need to call add_path_precheck.
     */
    foreach(p1, parent_rel->partial_pathlist)
    {
        Path       *old_path = (Path *) lfirst(p1);
        PathKeysComparison keyscmp;
 
        keyscmp = compare_pathkeys(pathkeys, old_path->pathkeys);
        if (keyscmp != PATHKEYS_DIFFERENT)
        {
            if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR &&
                keyscmp != PATHKEYS_BETTER1)
                return false;
            if (old_path->total_cost > total_cost * STD_FUZZ_FACTOR &&
                keyscmp != PATHKEYS_BETTER2)
                return true;
        }
    }
 
    /*
     * This path is neither clearly inferior to an existing partial path nor
     * clearly good enough that it might replace one.  Compare it to
     * non-parallel plans.  If it loses even before accounting for the cost of
     * the Gather node, we should definitely reject it.
     *
     * Note that we pass the total_cost to add_path_precheck twice.  This is
     * because it's never advantageous to consider the startup cost of a
     * partial path; the resulting plans, if run in parallel, will be run to
     * completion.
     */
    if (!add_path_precheck(parent_rel, disabled_nodes, total_cost, total_cost,
                           pathkeys, NULL))
        return false;
 
    return true;
}

References add_path_precheck(), compare_pathkeys(), lfirst, RelOptInfo::partial_pathlist, Path::pathkeys, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, STD_FUZZ_FACTOR, and Path::total_cost.

Referenced by try_partial_hashjoin_path(), try_partial_mergejoin_path(), and try_partial_nestloop_path().

add_path()

void add_path	(	RelOptInfo *	parent_rel,
		Path *	new_path
	)

Definition at line 461 of file pathnode.c.

{
    bool        accept_new = true;  /* unless we find a superior old path */
    int         insert_at = 0;  /* where to insert new item */
    List       *new_path_pathkeys;
    ListCell   *p1;
 
    /*
     * This is a convenient place to check for query cancel --- no part of the
     * planner goes very long without calling add_path().
     */
    CHECK_FOR_INTERRUPTS();
 
    /* Pretend parameterized paths have no pathkeys, per comment above */
    new_path_pathkeys = new_path->param_info ? NIL : new_path->pathkeys;
 
    /*
     * Loop to check proposed new path against old paths.  Note it is possible
     * for more than one old path to be tossed out because new_path dominates
     * it.
     */
    foreach(p1, parent_rel->pathlist)
    {
        Path       *old_path = (Path *) lfirst(p1);
        bool        remove_old = false; /* unless new proves superior */
        PathCostComparison costcmp;
        PathKeysComparison keyscmp;
        BMS_Comparison outercmp;
 
        /*
         * Do a fuzzy cost comparison with standard fuzziness limit.
         */
        costcmp = compare_path_costs_fuzzily(new_path, old_path,
                                             STD_FUZZ_FACTOR);
 
        /*
         * If the two paths compare differently for startup and total cost,
         * then we want to keep both, and we can skip comparing pathkeys and
         * required_outer rels.  If they compare the same, proceed with the
         * other comparisons.  Row count is checked last.  (We make the tests
         * in this order because the cost comparison is most likely to turn
         * out "different", and the pathkeys comparison next most likely.  As
         * explained above, row count very seldom makes a difference, so even
         * though it's cheap to compare there's not much point in checking it
         * earlier.)
         */
        if (costcmp != COSTS_DIFFERENT)
        {
            /* Similarly check to see if either dominates on pathkeys */
            List       *old_path_pathkeys;
 
            old_path_pathkeys = old_path->param_info ? NIL : old_path->pathkeys;
            keyscmp = compare_pathkeys(new_path_pathkeys,
                                       old_path_pathkeys);
            if (keyscmp != PATHKEYS_DIFFERENT)
            {
                switch (costcmp)
                {
                    case COSTS_EQUAL:
                        outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
                                                      PATH_REQ_OUTER(old_path));
                        if (keyscmp == PATHKEYS_BETTER1)
                        {
                            if ((outercmp == BMS_EQUAL ||
                                 outercmp == BMS_SUBSET1) &&
                                new_path->rows <= old_path->rows &&
                                new_path->parallel_safe >= old_path->parallel_safe)
                                remove_old = true;  /* new dominates old */
                        }
                        else if (keyscmp == PATHKEYS_BETTER2)
                        {
                            if ((outercmp == BMS_EQUAL ||
                                 outercmp == BMS_SUBSET2) &&
                                new_path->rows >= old_path->rows &&
                                new_path->parallel_safe <= old_path->parallel_safe)
                                accept_new = false; /* old dominates new */
                        }
                        else    /* keyscmp == PATHKEYS_EQUAL */
                        {
                            if (outercmp == BMS_EQUAL)
                            {
                                /*
                                 * Same pathkeys and outer rels, and fuzzily
                                 * the same cost, so keep just one; to decide
                                 * which, first check parallel-safety, then
                                 * rows, then do a fuzzy cost comparison with
                                 * very small fuzz limit.  (We used to do an
                                 * exact cost comparison, but that results in
                                 * annoying platform-specific plan variations
                                 * due to roundoff in the cost estimates.)  If
                                 * things are still tied, arbitrarily keep
                                 * only the old path.  Notice that we will
                                 * keep only the old path even if the
                                 * less-fuzzy comparison decides the startup
                                 * and total costs compare differently.
                                 */
                                if (new_path->parallel_safe >
                                    old_path->parallel_safe)
                                    remove_old = true;  /* new dominates old */
                                else if (new_path->parallel_safe <
                                         old_path->parallel_safe)
                                    accept_new = false; /* old dominates new */
                                else if (new_path->rows < old_path->rows)
                                    remove_old = true;  /* new dominates old */
                                else if (new_path->rows > old_path->rows)
                                    accept_new = false; /* old dominates new */
                                else if (compare_path_costs_fuzzily(new_path,
                                                                    old_path,
                                                                    1.0000000001) == COSTS_BETTER1)
                                    remove_old = true;  /* new dominates old */
                                else
                                    accept_new = false; /* old equals or
                                                         * dominates new */
                            }
                            else if (outercmp == BMS_SUBSET1 &&
                                     new_path->rows <= old_path->rows &&
                                     new_path->parallel_safe >= old_path->parallel_safe)
                                remove_old = true;  /* new dominates old */
                            else if (outercmp == BMS_SUBSET2 &&
                                     new_path->rows >= old_path->rows &&
                                     new_path->parallel_safe <= old_path->parallel_safe)
                                accept_new = false; /* old dominates new */
                            /* else different parameterizations, keep both */
                        }
                        break;
                    case COSTS_BETTER1:
                        if (keyscmp != PATHKEYS_BETTER2)
                        {
                            outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
                                                          PATH_REQ_OUTER(old_path));
                            if ((outercmp == BMS_EQUAL ||
                                 outercmp == BMS_SUBSET1) &&
                                new_path->rows <= old_path->rows &&
                                new_path->parallel_safe >= old_path->parallel_safe)
                                remove_old = true;  /* new dominates old */
                        }
                        break;
                    case COSTS_BETTER2:
                        if (keyscmp != PATHKEYS_BETTER1)
                        {
                            outercmp = bms_subset_compare(PATH_REQ_OUTER(new_path),
                                                          PATH_REQ_OUTER(old_path));
                            if ((outercmp == BMS_EQUAL ||
                                 outercmp == BMS_SUBSET2) &&
                                new_path->rows >= old_path->rows &&
                                new_path->parallel_safe <= old_path->parallel_safe)
                                accept_new = false; /* old dominates new */
                        }
                        break;
                    case COSTS_DIFFERENT:
 
                        /*
                         * can't get here, but keep this case to keep compiler
                         * quiet
                         */
                        break;
                }
            }
        }
 
        /*
         * Remove current element from pathlist if dominated by new.
         */
        if (remove_old)
        {
            parent_rel->pathlist = foreach_delete_current(parent_rel->pathlist,
                                                          p1);
 
            /*
             * Delete the data pointed-to by the deleted cell, if possible
             */
            if (!IsA(old_path, IndexPath))
                pfree(old_path);
        }
        else
        {
            /*
             * new belongs after this old path if it has more disabled nodes
             * or if it has the same number of nodes but a greater total cost
             */
            if (new_path->disabled_nodes > old_path->disabled_nodes ||
                (new_path->disabled_nodes == old_path->disabled_nodes &&
                 new_path->total_cost >= old_path->total_cost))
                insert_at = foreach_current_index(p1) + 1;
        }
 
        /*
         * If we found an old path that dominates new_path, we can quit
         * scanning the pathlist; we will not add new_path, and we assume
         * new_path cannot dominate any other elements of the pathlist.
         */
        if (!accept_new)
            break;
    }
 
    if (accept_new)
    {
        /* Accept the new path: insert it at proper place in pathlist */
        parent_rel->pathlist =
            list_insert_nth(parent_rel->pathlist, insert_at, new_path);
    }
    else
    {
        /* Reject and recycle the new path */
        if (!IsA(new_path, IndexPath))
            pfree(new_path);
    }
}

References BMS_EQUAL, BMS_SUBSET1, BMS_SUBSET2, bms_subset_compare(), CHECK_FOR_INTERRUPTS, compare_path_costs_fuzzily(), compare_pathkeys(), COSTS_BETTER1, COSTS_BETTER2, COSTS_DIFFERENT, COSTS_EQUAL, Path::disabled_nodes, foreach_current_index, foreach_delete_current, IsA, lfirst, list_insert_nth(), NIL, Path::parallel_safe, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_BETTER1, PATHKEYS_BETTER2, PATHKEYS_DIFFERENT, RelOptInfo::pathlist, pfree(), Path::rows, STD_FUZZ_FACTOR, and Path::total_cost.

Referenced by add_foreign_final_paths(), add_foreign_grouping_paths(), add_foreign_ordered_paths(), add_paths_to_append_rel(), add_paths_to_grouping_rel(), add_paths_with_pathkeys_for_rel(), build_setop_child_paths(), BuildParameterizedTidPaths(), consider_groupingsets_paths(), create_degenerate_grouping_paths(), create_final_distinct_paths(), create_index_paths(), create_one_window_path(), create_ordered_paths(), create_partial_grouping_paths(), create_tidscan_paths(), fileGetForeignPaths(), gather_grouping_paths(), generate_gather_paths(), generate_nonunion_paths(), generate_orderedappend_paths(), generate_recursion_path(), generate_union_paths(), generate_useful_gather_paths(), get_index_paths(), grouping_planner(), mark_dummy_rel(), postgresGetForeignJoinPaths(), postgresGetForeignPaths(), preprocess_minmax_aggregates(), query_planner(), set_cte_pathlist(), set_dummy_rel_pathlist(), set_function_pathlist(), set_namedtuplestore_pathlist(), set_plain_rel_pathlist(), set_result_pathlist(), set_subquery_pathlist(), set_tablefunc_pathlist(), set_tablesample_rel_pathlist(), set_values_pathlist(), set_worktable_pathlist(), try_hashjoin_path(), try_mergejoin_path(), and try_nestloop_path().

add_path_precheck()

bool add_path_precheck	(	RelOptInfo *	parent_rel,
		int	disabled_nodes,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 688 of file pathnode.c.

{
    List       *new_path_pathkeys;
    bool        consider_startup;
    ListCell   *p1;
 
    /* Pretend parameterized paths have no pathkeys, per add_path policy */
    new_path_pathkeys = required_outer ? NIL : pathkeys;
 
    /* Decide whether new path's startup cost is interesting */
    consider_startup = required_outer ? parent_rel->consider_param_startup : parent_rel->consider_startup;
 
    foreach(p1, parent_rel->pathlist)
    {
        Path       *old_path = (Path *) lfirst(p1);
        PathKeysComparison keyscmp;
 
        /*
         * Since the pathlist is sorted by disabled_nodes and then by
         * total_cost, we can stop looking once we reach a path with more
         * disabled nodes, or the same number of disabled nodes plus a
         * total_cost larger than the new path's.
         */
        if (unlikely(old_path->disabled_nodes != disabled_nodes))
        {
            if (disabled_nodes < old_path->disabled_nodes)
                break;
        }
        else if (total_cost <= old_path->total_cost * STD_FUZZ_FACTOR)
            break;
 
        /*
         * We are looking for an old_path with the same parameterization (and
         * by assumption the same rowcount) that dominates the new path on
         * pathkeys as well as both cost metrics.  If we find one, we can
         * reject the new path.
         *
         * Cost comparisons here should match compare_path_costs_fuzzily.
         */
        /* new path can win on startup cost only if consider_startup */
        if (startup_cost > old_path->startup_cost * STD_FUZZ_FACTOR ||
            !consider_startup)
        {
            /* new path loses on cost, so check pathkeys... */
            List       *old_path_pathkeys;
 
            old_path_pathkeys = old_path->param_info ? NIL : old_path->pathkeys;
            keyscmp = compare_pathkeys(new_path_pathkeys,
                                       old_path_pathkeys);
            if (keyscmp == PATHKEYS_EQUAL ||
                keyscmp == PATHKEYS_BETTER2)
            {
                /* new path does not win on pathkeys... */
                if (bms_equal(required_outer, PATH_REQ_OUTER(old_path)))
                {
                    /* Found an old path that dominates the new one */
                    return false;
                }
            }
        }
    }
 
    return true;
}

References bms_equal(), compare_pathkeys(), RelOptInfo::consider_param_startup, RelOptInfo::consider_startup, Path::disabled_nodes, lfirst, NIL, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_BETTER2, PATHKEYS_EQUAL, RelOptInfo::pathlist, Path::startup_cost, STD_FUZZ_FACTOR, and unlikely.

Referenced by add_partial_path_precheck(), try_hashjoin_path(), try_mergejoin_path(), and try_nestloop_path().

adjust_limit_rows_costs()

void adjust_limit_rows_costs	(	double *	rows,
		Cost *	startup_cost,
		Cost *	total_cost,
		int64	offset_est,
		int64	count_est
	)

Definition at line 4038 of file pathnode.c.

{
    double      input_rows = *rows;
    Cost        input_startup_cost = *startup_cost;
    Cost        input_total_cost = *total_cost;
 
    if (offset_est != 0)
    {
        double      offset_rows;
 
        if (offset_est > 0)
            offset_rows = (double) offset_est;
        else
            offset_rows = clamp_row_est(input_rows * 0.10);
        if (offset_rows > *rows)
            offset_rows = *rows;
        if (input_rows > 0)
            *startup_cost +=
                (input_total_cost - input_startup_cost)
                * offset_rows / input_rows;
        *rows -= offset_rows;
        if (*rows < 1)
            *rows = 1;
    }
 
    if (count_est != 0)
    {
        double      count_rows;
 
        if (count_est > 0)
            count_rows = (double) count_est;
        else
            count_rows = clamp_row_est(input_rows * 0.10);
        if (count_rows > *rows)
            count_rows = *rows;
        if (input_rows > 0)
            *total_cost = *startup_cost +
                (input_total_cost - input_startup_cost)
                * count_rows / input_rows;
        *rows = count_rows;
        if (*rows < 1)
            *rows = 1;
    }
}

References clamp_row_est().

Referenced by create_limit_path(), and estimate_path_cost_size().

apply_projection_to_path()

Path * apply_projection_to_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	path,
		PathTarget *	target
	)

Definition at line 2876 of file pathnode.c.

{
    QualCost    oldcost;
 
    /*
     * If given path can't project, we might need a Result node, so make a
     * separate ProjectionPath.
     */
    if (!is_projection_capable_path(path))
        return (Path *) create_projection_path(root, rel, path, target);
 
    /*
     * We can just jam the desired tlist into the existing path, being sure to
     * update its cost estimates appropriately.
     */
    oldcost = path->pathtarget->cost;
    path->pathtarget = target;
 
    path->startup_cost += target->cost.startup - oldcost.startup;
    path->total_cost += target->cost.startup - oldcost.startup +
        (target->cost.per_tuple - oldcost.per_tuple) * path->rows;
 
    /*
     * If the path happens to be a Gather or GatherMerge path, we'd like to
     * arrange for the subpath to return the required target list so that
     * workers can help project.  But if there is something that is not
     * parallel-safe in the target expressions, then we can't.
     */
    if ((IsA(path, GatherPath) || IsA(path, GatherMergePath)) &&
        is_parallel_safe(root, (Node *) target->exprs))
    {
        /*
         * We always use create_projection_path here, even if the subpath is
         * projection-capable, so as to avoid modifying the subpath in place.
         * It seems unlikely at present that there could be any other
         * references to the subpath, but better safe than sorry.
         *
         * Note that we don't change the parallel path's cost estimates; it
         * might be appropriate to do so, to reflect the fact that the bulk of
         * the target evaluation will happen in workers.
         */
        if (IsA(path, GatherPath))
        {
            GatherPath *gpath = (GatherPath *) path;
 
            gpath->subpath = (Path *)
                create_projection_path(root,
                                       gpath->subpath->parent,
                                       gpath->subpath,
                                       target);
        }
        else
        {
            GatherMergePath *gmpath = (GatherMergePath *) path;
 
            gmpath->subpath = (Path *)
                create_projection_path(root,
                                       gmpath->subpath->parent,
                                       gmpath->subpath,
                                       target);
        }
    }
    else if (path->parallel_safe &&
             !is_parallel_safe(root, (Node *) target->exprs))
    {
        /*
         * We're inserting a parallel-restricted target list into a path
         * currently marked parallel-safe, so we have to mark it as no longer
         * safe.
         */
        path->parallel_safe = false;
    }
 
    return path;
}

References PathTarget::cost, create_projection_path(), PathTarget::exprs, if(), is_parallel_safe(), is_projection_capable_path(), IsA, Path::parallel_safe, QualCost::per_tuple, root, Path::rows, QualCost::startup, Path::startup_cost, GatherPath::subpath, GatherMergePath::subpath, and Path::total_cost.

Referenced by adjust_paths_for_srfs(), build_minmax_path(), create_ordered_paths(), and recurse_set_operations().

build_child_join_rel()

RelOptInfo * build_child_join_rel	(	PlannerInfo *	root,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		RelOptInfo *	parent_joinrel,
		List *	restrictlist,
		SpecialJoinInfo *	sjinfo,
		int	nappinfos,
		AppendRelInfo **	appinfos
	)

Definition at line 882 of file relnode.c.

{
    RelOptInfo *joinrel = makeNode(RelOptInfo);
 
    /* Only joins between "other" relations land here. */
    Assert(IS_OTHER_REL(outer_rel) && IS_OTHER_REL(inner_rel));
 
    /* The parent joinrel should have consider_partitionwise_join set. */
    Assert(parent_joinrel->consider_partitionwise_join);
 
    joinrel->reloptkind = RELOPT_OTHER_JOINREL;
    joinrel->relids = adjust_child_relids(parent_joinrel->relids,
                                          nappinfos, appinfos);
    joinrel->rows = 0;
    /* cheap startup cost is interesting iff not all tuples to be retrieved */
    joinrel->consider_startup = (root->tuple_fraction > 0);
    joinrel->consider_param_startup = false;
    joinrel->consider_parallel = false;
    joinrel->reltarget = create_empty_pathtarget();
    joinrel->pathlist = NIL;
    joinrel->ppilist = NIL;
    joinrel->partial_pathlist = NIL;
    joinrel->cheapest_startup_path = NULL;
    joinrel->cheapest_total_path = NULL;
    joinrel->cheapest_unique_path = NULL;
    joinrel->cheapest_parameterized_paths = NIL;
    joinrel->direct_lateral_relids = NULL;
    joinrel->lateral_relids = NULL;
    joinrel->relid = 0;         /* indicates not a baserel */
    joinrel->rtekind = RTE_JOIN;
    joinrel->min_attr = 0;
    joinrel->max_attr = 0;
    joinrel->attr_needed = NULL;
    joinrel->attr_widths = NULL;
    joinrel->notnullattnums = NULL;
    joinrel->nulling_relids = NULL;
    joinrel->lateral_vars = NIL;
    joinrel->lateral_referencers = NULL;
    joinrel->indexlist = NIL;
    joinrel->pages = 0;
    joinrel->tuples = 0;
    joinrel->allvisfrac = 0;
    joinrel->eclass_indexes = NULL;
    joinrel->subroot = NULL;
    joinrel->subplan_params = NIL;
    joinrel->amflags = 0;
    joinrel->serverid = InvalidOid;
    joinrel->userid = InvalidOid;
    joinrel->useridiscurrent = false;
    joinrel->fdwroutine = NULL;
    joinrel->fdw_private = NULL;
    joinrel->baserestrictinfo = NIL;
    joinrel->baserestrictcost.startup = 0;
    joinrel->baserestrictcost.per_tuple = 0;
    joinrel->joininfo = NIL;
    joinrel->has_eclass_joins = false;
    joinrel->consider_partitionwise_join = false;   /* might get changed later */
    joinrel->parent = parent_joinrel;
    joinrel->top_parent = parent_joinrel->top_parent ? parent_joinrel->top_parent : parent_joinrel;
    joinrel->top_parent_relids = joinrel->top_parent->relids;
    joinrel->part_scheme = NULL;
    joinrel->nparts = -1;
    joinrel->boundinfo = NULL;
    joinrel->partbounds_merged = false;
    joinrel->partition_qual = NIL;
    joinrel->part_rels = NULL;
    joinrel->live_parts = NULL;
    joinrel->all_partrels = NULL;
    joinrel->partexprs = NULL;
    joinrel->nullable_partexprs = NULL;
 
    /* Compute information relevant to foreign relations. */
    set_foreign_rel_properties(joinrel, outer_rel, inner_rel);
 
    /* Set up reltarget struct */
    build_child_join_reltarget(root, parent_joinrel, joinrel,
                               nappinfos, appinfos);
 
    /* Construct joininfo list. */
    joinrel->joininfo = (List *) adjust_appendrel_attrs(root,
                                                        (Node *) parent_joinrel->joininfo,
                                                        nappinfos,
                                                        appinfos);
 
    /*
     * Lateral relids referred in child join will be same as that referred in
     * the parent relation.
     */
    joinrel->direct_lateral_relids = (Relids) bms_copy(parent_joinrel->direct_lateral_relids);
    joinrel->lateral_relids = (Relids) bms_copy(parent_joinrel->lateral_relids);
 
    /*
     * If the parent joinrel has pending equivalence classes, so does the
     * child.
     */
    joinrel->has_eclass_joins = parent_joinrel->has_eclass_joins;
 
    /* Is the join between partitions itself partitioned? */
    build_joinrel_partition_info(root, joinrel, outer_rel, inner_rel, sjinfo,
                                 restrictlist);
 
    /* Child joinrel is parallel safe if parent is parallel safe. */
    joinrel->consider_parallel = parent_joinrel->consider_parallel;
 
    /* Set estimates of the child-joinrel's size. */
    set_joinrel_size_estimates(root, joinrel, outer_rel, inner_rel,
                               sjinfo, restrictlist);
 
    /* We build the join only once. */
    Assert(!find_join_rel(root, joinrel->relids));
 
    /* Add the relation to the PlannerInfo. */
    add_join_rel(root, joinrel);
 
    /*
     * We might need EquivalenceClass members corresponding to the child join,
     * so that we can represent sort pathkeys for it.  As with children of
     * baserels, we shouldn't need this unless there are relevant eclass joins
     * (implying that a merge join might be possible) or pathkeys to sort by.
     */
    if (joinrel->has_eclass_joins || has_useful_pathkeys(root, parent_joinrel))
        add_child_join_rel_equivalences(root,
                                        nappinfos, appinfos,
                                        parent_joinrel, joinrel);
 
    return joinrel;
}

References add_child_join_rel_equivalences(), add_join_rel(), adjust_appendrel_attrs(), adjust_child_relids(), RelOptInfo::all_partrels, RelOptInfo::allvisfrac, RelOptInfo::amflags, Assert(), RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, bms_copy(), build_child_join_reltarget(), build_joinrel_partition_info(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, RelOptInfo::consider_parallel, RelOptInfo::consider_param_startup, RelOptInfo::consider_partitionwise_join, RelOptInfo::consider_startup, create_empty_pathtarget(), RelOptInfo::direct_lateral_relids, RelOptInfo::eclass_indexes, find_join_rel(), RelOptInfo::has_eclass_joins, has_useful_pathkeys(), RelOptInfo::indexlist, InvalidOid, IS_OTHER_REL, RelOptInfo::joininfo, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, RelOptInfo::lateral_vars, RelOptInfo::live_parts, makeNode, RelOptInfo::max_attr, RelOptInfo::min_attr, NIL, RelOptInfo::notnullattnums, RelOptInfo::nparts, RelOptInfo::nulling_relids, RelOptInfo::pages, RelOptInfo::partbounds_merged, RelOptInfo::partial_pathlist, RelOptInfo::partition_qual, RelOptInfo::pathlist, QualCost::per_tuple, RelOptInfo::ppilist, RelOptInfo::relid, RelOptInfo::relids, RELOPT_OTHER_JOINREL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::rows, RTE_JOIN, RelOptInfo::rtekind, RelOptInfo::serverid, set_foreign_rel_properties(), set_joinrel_size_estimates(), QualCost::startup, RelOptInfo::subplan_params, RelOptInfo::subroot, RelOptInfo::top_parent_relids, RelOptInfo::tuples, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by try_partitionwise_join().

build_join_rel()

RelOptInfo * build_join_rel	(	PlannerInfo *	root,
		Relids	joinrelids,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		SpecialJoinInfo *	sjinfo,
		List *	pushed_down_joins,
		List **	restrictlist_ptr
	)

Definition at line 665 of file relnode.c.

{
    RelOptInfo *joinrel;
    List       *restrictlist;
 
    /* This function should be used only for join between parents. */
    Assert(!IS_OTHER_REL(outer_rel) && !IS_OTHER_REL(inner_rel));
 
    /*
     * See if we already have a joinrel for this set of base rels.
     */
    joinrel = find_join_rel(root, joinrelids);
 
    if (joinrel)
    {
        /*
         * Yes, so we only need to figure the restrictlist for this particular
         * pair of component relations.
         */
        if (restrictlist_ptr)
            *restrictlist_ptr = build_joinrel_restrictlist(root,
                                                           joinrel,
                                                           outer_rel,
                                                           inner_rel,
                                                           sjinfo);
        return joinrel;
    }
 
    /*
     * Nope, so make one.
     */
    joinrel = makeNode(RelOptInfo);
    joinrel->reloptkind = RELOPT_JOINREL;
    joinrel->relids = bms_copy(joinrelids);
    joinrel->rows = 0;
    /* cheap startup cost is interesting iff not all tuples to be retrieved */
    joinrel->consider_startup = (root->tuple_fraction > 0);
    joinrel->consider_param_startup = false;
    joinrel->consider_parallel = false;
    joinrel->reltarget = create_empty_pathtarget();
    joinrel->pathlist = NIL;
    joinrel->ppilist = NIL;
    joinrel->partial_pathlist = NIL;
    joinrel->cheapest_startup_path = NULL;
    joinrel->cheapest_total_path = NULL;
    joinrel->cheapest_unique_path = NULL;
    joinrel->cheapest_parameterized_paths = NIL;
    /* init direct_lateral_relids from children; we'll finish it up below */
    joinrel->direct_lateral_relids =
        bms_union(outer_rel->direct_lateral_relids,
                  inner_rel->direct_lateral_relids);
    joinrel->lateral_relids = min_join_parameterization(root, joinrel->relids,
                                                        outer_rel, inner_rel);
    joinrel->relid = 0;         /* indicates not a baserel */
    joinrel->rtekind = RTE_JOIN;
    joinrel->min_attr = 0;
    joinrel->max_attr = 0;
    joinrel->attr_needed = NULL;
    joinrel->attr_widths = NULL;
    joinrel->notnullattnums = NULL;
    joinrel->nulling_relids = NULL;
    joinrel->lateral_vars = NIL;
    joinrel->lateral_referencers = NULL;
    joinrel->indexlist = NIL;
    joinrel->statlist = NIL;
    joinrel->pages = 0;
    joinrel->tuples = 0;
    joinrel->allvisfrac = 0;
    joinrel->eclass_indexes = NULL;
    joinrel->subroot = NULL;
    joinrel->subplan_params = NIL;
    joinrel->rel_parallel_workers = -1;
    joinrel->amflags = 0;
    joinrel->serverid = InvalidOid;
    joinrel->userid = InvalidOid;
    joinrel->useridiscurrent = false;
    joinrel->fdwroutine = NULL;
    joinrel->fdw_private = NULL;
    joinrel->unique_for_rels = NIL;
    joinrel->non_unique_for_rels = NIL;
    joinrel->baserestrictinfo = NIL;
    joinrel->baserestrictcost.startup = 0;
    joinrel->baserestrictcost.per_tuple = 0;
    joinrel->baserestrict_min_security = UINT_MAX;
    joinrel->joininfo = NIL;
    joinrel->has_eclass_joins = false;
    joinrel->consider_partitionwise_join = false;   /* might get changed later */
    joinrel->parent = NULL;
    joinrel->top_parent = NULL;
    joinrel->top_parent_relids = NULL;
    joinrel->part_scheme = NULL;
    joinrel->nparts = -1;
    joinrel->boundinfo = NULL;
    joinrel->partbounds_merged = false;
    joinrel->partition_qual = NIL;
    joinrel->part_rels = NULL;
    joinrel->live_parts = NULL;
    joinrel->all_partrels = NULL;
    joinrel->partexprs = NULL;
    joinrel->nullable_partexprs = NULL;
 
    /* Compute information relevant to the foreign relations. */
    set_foreign_rel_properties(joinrel, outer_rel, inner_rel);
 
    /*
     * Fill the joinrel's tlist with just the Vars and PHVs that need to be
     * output from this join (ie, are needed for higher joinclauses or final
     * output).
     *
     * NOTE: the tlist order for a join rel will depend on which pair of outer
     * and inner rels we first try to build it from.  But the contents should
     * be the same regardless.
     */
    build_joinrel_tlist(root, joinrel, outer_rel, sjinfo, pushed_down_joins,
                        (sjinfo->jointype == JOIN_FULL));
    build_joinrel_tlist(root, joinrel, inner_rel, sjinfo, pushed_down_joins,
                        (sjinfo->jointype != JOIN_INNER));
    add_placeholders_to_joinrel(root, joinrel, outer_rel, inner_rel, sjinfo);
 
    /*
     * add_placeholders_to_joinrel also took care of adding the ph_lateral
     * sets of any PlaceHolderVars computed here to direct_lateral_relids, so
     * now we can finish computing that.  This is much like the computation of
     * the transitively-closed lateral_relids in min_join_parameterization,
     * except that here we *do* have to consider the added PHVs.
     */
    joinrel->direct_lateral_relids =
        bms_del_members(joinrel->direct_lateral_relids, joinrel->relids);
 
    /*
     * Construct restrict and join clause lists for the new joinrel. (The
     * caller might or might not need the restrictlist, but I need it anyway
     * for set_joinrel_size_estimates().)
     */
    restrictlist = build_joinrel_restrictlist(root, joinrel,
                                              outer_rel, inner_rel,
                                              sjinfo);
    if (restrictlist_ptr)
        *restrictlist_ptr = restrictlist;
    build_joinrel_joinlist(joinrel, outer_rel, inner_rel);
 
    /*
     * This is also the right place to check whether the joinrel has any
     * pending EquivalenceClass joins.
     */
    joinrel->has_eclass_joins = has_relevant_eclass_joinclause(root, joinrel);
 
    /* Store the partition information. */
    build_joinrel_partition_info(root, joinrel, outer_rel, inner_rel, sjinfo,
                                 restrictlist);
 
    /*
     * Set estimates of the joinrel's size.
     */
    set_joinrel_size_estimates(root, joinrel, outer_rel, inner_rel,
                               sjinfo, restrictlist);
 
    /*
     * Set the consider_parallel flag if this joinrel could potentially be
     * scanned within a parallel worker.  If this flag is false for either
     * inner_rel or outer_rel, then it must be false for the joinrel also.
     * Even if both are true, there might be parallel-restricted expressions
     * in the targetlist or quals.
     *
     * Note that if there are more than two rels in this relation, they could
     * be divided between inner_rel and outer_rel in any arbitrary way.  We
     * assume this doesn't matter, because we should hit all the same baserels
     * and joinclauses while building up to this joinrel no matter which we
     * take; therefore, we should make the same decision here however we get
     * here.
     */
    if (inner_rel->consider_parallel && outer_rel->consider_parallel &&
        is_parallel_safe(root, (Node *) restrictlist) &&
        is_parallel_safe(root, (Node *) joinrel->reltarget->exprs))
        joinrel->consider_parallel = true;
 
    /* Add the joinrel to the PlannerInfo. */
    add_join_rel(root, joinrel);
 
    /*
     * Also, if dynamic-programming join search is active, add the new joinrel
     * to the appropriate sublist.  Note: you might think the Assert on number
     * of members should be for equality, but some of the level 1 rels might
     * have been joinrels already, so we can only assert <=.
     */
    if (root->join_rel_level)
    {
        Assert(root->join_cur_level > 0);
        Assert(root->join_cur_level <= bms_num_members(joinrel->relids));
        root->join_rel_level[root->join_cur_level] =
            lappend(root->join_rel_level[root->join_cur_level], joinrel);
    }
 
    return joinrel;
}

References add_join_rel(), add_placeholders_to_joinrel(), RelOptInfo::all_partrels, RelOptInfo::allvisfrac, RelOptInfo::amflags, Assert(), RelOptInfo::baserestrict_min_security, RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, bms_copy(), bms_del_members(), bms_num_members(), bms_union(), build_joinrel_joinlist(), build_joinrel_partition_info(), build_joinrel_restrictlist(), build_joinrel_tlist(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, RelOptInfo::consider_parallel, RelOptInfo::consider_param_startup, RelOptInfo::consider_partitionwise_join, RelOptInfo::consider_startup, create_empty_pathtarget(), RelOptInfo::direct_lateral_relids, RelOptInfo::eclass_indexes, PathTarget::exprs, find_join_rel(), RelOptInfo::has_eclass_joins, has_relevant_eclass_joinclause(), RelOptInfo::indexlist, InvalidOid, IS_OTHER_REL, is_parallel_safe(), JOIN_FULL, JOIN_INNER, RelOptInfo::joininfo, SpecialJoinInfo::jointype, lappend(), RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, RelOptInfo::lateral_vars, RelOptInfo::live_parts, makeNode, RelOptInfo::max_attr, RelOptInfo::min_attr, min_join_parameterization(), NIL, RelOptInfo::non_unique_for_rels, RelOptInfo::notnullattnums, RelOptInfo::nparts, RelOptInfo::nulling_relids, RelOptInfo::pages, RelOptInfo::partbounds_merged, RelOptInfo::partial_pathlist, RelOptInfo::partition_qual, RelOptInfo::pathlist, QualCost::per_tuple, RelOptInfo::ppilist, RelOptInfo::rel_parallel_workers, RelOptInfo::relid, RelOptInfo::relids, RELOPT_JOINREL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::rows, RTE_JOIN, RelOptInfo::rtekind, RelOptInfo::serverid, set_foreign_rel_properties(), set_joinrel_size_estimates(), QualCost::startup, RelOptInfo::statlist, RelOptInfo::subplan_params, RelOptInfo::subroot, RelOptInfo::top_parent_relids, RelOptInfo::tuples, RelOptInfo::unique_for_rels, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by make_join_rel().

build_simple_rel()

RelOptInfo * build_simple_rel	(	PlannerInfo *	root,
		int	relid,
		RelOptInfo *	parent
	)

Definition at line 192 of file relnode.c.

{
    RelOptInfo *rel;
    RangeTblEntry *rte;
 
    /* Rel should not exist already */
    Assert(relid > 0 && relid < root->simple_rel_array_size);
    if (root->simple_rel_array[relid] != NULL)
        elog(ERROR, "rel %d already exists", relid);
 
    /* Fetch RTE for relation */
    rte = root->simple_rte_array[relid];
    Assert(rte != NULL);
 
    rel = makeNode(RelOptInfo);
    rel->reloptkind = parent ? RELOPT_OTHER_MEMBER_REL : RELOPT_BASEREL;
    rel->relids = bms_make_singleton(relid);
    rel->rows = 0;
    /* cheap startup cost is interesting iff not all tuples to be retrieved */
    rel->consider_startup = (root->tuple_fraction > 0);
    rel->consider_param_startup = false;    /* might get changed later */
    rel->consider_parallel = false; /* might get changed later */
    rel->reltarget = create_empty_pathtarget();
    rel->pathlist = NIL;
    rel->ppilist = NIL;
    rel->partial_pathlist = NIL;
    rel->cheapest_startup_path = NULL;
    rel->cheapest_total_path = NULL;
    rel->cheapest_unique_path = NULL;
    rel->cheapest_parameterized_paths = NIL;
    rel->relid = relid;
    rel->rtekind = rte->rtekind;
    /* min_attr, max_attr, attr_needed, attr_widths are set below */
    rel->notnullattnums = NULL;
    rel->lateral_vars = NIL;
    rel->indexlist = NIL;
    rel->statlist = NIL;
    rel->pages = 0;
    rel->tuples = 0;
    rel->allvisfrac = 0;
    rel->eclass_indexes = NULL;
    rel->subroot = NULL;
    rel->subplan_params = NIL;
    rel->rel_parallel_workers = -1; /* set up in get_relation_info */
    rel->amflags = 0;
    rel->serverid = InvalidOid;
    if (rte->rtekind == RTE_RELATION)
    {
        Assert(parent == NULL ||
               parent->rtekind == RTE_RELATION ||
               parent->rtekind == RTE_SUBQUERY);
 
        /*
         * For any RELATION rte, we need a userid with which to check
         * permission access. Baserels simply use their own
         * RTEPermissionInfo's checkAsUser.
         *
         * For otherrels normally there's no RTEPermissionInfo, so we use the
         * parent's, which normally has one. The exceptional case is that the
         * parent is a subquery, in which case the otherrel will have its own.
         */
        if (rel->reloptkind == RELOPT_BASEREL ||
            (rel->reloptkind == RELOPT_OTHER_MEMBER_REL &&
             parent->rtekind == RTE_SUBQUERY))
        {
            RTEPermissionInfo *perminfo;
 
            perminfo = getRTEPermissionInfo(root->parse->rteperminfos, rte);
            rel->userid = perminfo->checkAsUser;
        }
        else
            rel->userid = parent->userid;
    }
    else
        rel->userid = InvalidOid;
    rel->useridiscurrent = false;
    rel->fdwroutine = NULL;
    rel->fdw_private = NULL;
    rel->unique_for_rels = NIL;
    rel->non_unique_for_rels = NIL;
    rel->baserestrictinfo = NIL;
    rel->baserestrictcost.startup = 0;
    rel->baserestrictcost.per_tuple = 0;
    rel->baserestrict_min_security = UINT_MAX;
    rel->joininfo = NIL;
    rel->has_eclass_joins = false;
    rel->consider_partitionwise_join = false;   /* might get changed later */
    rel->part_scheme = NULL;
    rel->nparts = -1;
    rel->boundinfo = NULL;
    rel->partbounds_merged = false;
    rel->partition_qual = NIL;
    rel->part_rels = NULL;
    rel->live_parts = NULL;
    rel->all_partrels = NULL;
    rel->partexprs = NULL;
    rel->nullable_partexprs = NULL;
 
    /*
     * Pass assorted information down the inheritance hierarchy.
     */
    if (parent)
    {
        /* We keep back-links to immediate parent and topmost parent. */
        rel->parent = parent;
        rel->top_parent = parent->top_parent ? parent->top_parent : parent;
        rel->top_parent_relids = rel->top_parent->relids;
 
        /*
         * A child rel is below the same outer joins as its parent.  (We
         * presume this info was already calculated for the parent.)
         */
        rel->nulling_relids = parent->nulling_relids;
 
        /*
         * Also propagate lateral-reference information from appendrel parent
         * rels to their child rels.  We intentionally give each child rel the
         * same minimum parameterization, even though it's quite possible that
         * some don't reference all the lateral rels.  This is because any
         * append path for the parent will have to have the same
         * parameterization for every child anyway, and there's no value in
         * forcing extra reparameterize_path() calls.  Similarly, a lateral
         * reference to the parent prevents use of otherwise-movable join rels
         * for each child.
         *
         * It's possible for child rels to have their own children, in which
         * case the topmost parent's lateral info propagates all the way down.
         */
        rel->direct_lateral_relids = parent->direct_lateral_relids;
        rel->lateral_relids = parent->lateral_relids;
        rel->lateral_referencers = parent->lateral_referencers;
    }
    else
    {
        rel->parent = NULL;
        rel->top_parent = NULL;
        rel->top_parent_relids = NULL;
        rel->nulling_relids = NULL;
        rel->direct_lateral_relids = NULL;
        rel->lateral_relids = NULL;
        rel->lateral_referencers = NULL;
    }
 
    /* Check type of rtable entry */
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            /* Table --- retrieve statistics from the system catalogs */
            get_relation_info(root, rte->relid, rte->inh, rel);
            break;
        case RTE_SUBQUERY:
        case RTE_FUNCTION:
        case RTE_TABLEFUNC:
        case RTE_VALUES:
        case RTE_CTE:
        case RTE_NAMEDTUPLESTORE:
 
            /*
             * Subquery, function, tablefunc, values list, CTE, or ENR --- set
             * up attr range and arrays
             *
             * Note: 0 is included in range to support whole-row Vars
             */
            rel->min_attr = 0;
            rel->max_attr = list_length(rte->eref->colnames);
            rel->attr_needed = (Relids *)
                palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(Relids));
            rel->attr_widths = (int32 *)
                palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(int32));
            break;
        case RTE_RESULT:
            /* RTE_RESULT has no columns, nor could it have whole-row Var */
            rel->min_attr = 0;
            rel->max_attr = -1;
            rel->attr_needed = NULL;
            rel->attr_widths = NULL;
            break;
        default:
            elog(ERROR, "unrecognized RTE kind: %d",
                 (int) rte->rtekind);
            break;
    }
 
    /*
     * We must apply the partially filled in RelOptInfo before calling
     * apply_child_basequals due to some transformations within that function
     * which require the RelOptInfo to be available in the simple_rel_array.
     */
    root->simple_rel_array[relid] = rel;
 
    /*
     * Apply the parent's quals to the child, with appropriate substitution of
     * variables.  If the resulting clause is constant-FALSE or NULL after
     * applying transformations, apply_child_basequals returns false to
     * indicate that scanning this relation won't yield any rows.  In this
     * case, we mark the child as dummy right away.  (We must do this
     * immediately so that pruning works correctly when recursing in
     * expand_partitioned_rtentry.)
     */
    if (parent)
    {
        AppendRelInfo *appinfo = root->append_rel_array[relid];
 
        Assert(appinfo != NULL);
        if (!apply_child_basequals(root, parent, rel, rte, appinfo))
        {
            /*
             * Restriction clause reduced to constant FALSE or NULL.  Mark as
             * dummy so we won't scan this relation.
             */
            mark_dummy_rel(rel);
        }
    }
 
    return rel;
}

References RelOptInfo::all_partrels, RelOptInfo::allvisfrac, RelOptInfo::amflags, apply_child_basequals(), Assert(), RelOptInfo::baserestrict_min_security, RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, bms_make_singleton(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, RTEPermissionInfo::checkAsUser, RelOptInfo::consider_parallel, RelOptInfo::consider_param_startup, RelOptInfo::consider_partitionwise_join, RelOptInfo::consider_startup, create_empty_pathtarget(), RelOptInfo::direct_lateral_relids, RelOptInfo::eclass_indexes, elog, ERROR, get_relation_info(), getRTEPermissionInfo(), RelOptInfo::has_eclass_joins, RelOptInfo::indexlist, RangeTblEntry::inh, InvalidOid, RelOptInfo::joininfo, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, RelOptInfo::lateral_vars, list_length(), RelOptInfo::live_parts, makeNode, mark_dummy_rel(), RelOptInfo::max_attr, RelOptInfo::min_attr, NIL, RelOptInfo::non_unique_for_rels, RelOptInfo::notnullattnums, RelOptInfo::nparts, RelOptInfo::nulling_relids, RelOptInfo::pages, palloc0(), RelOptInfo::partbounds_merged, RelOptInfo::partial_pathlist, RelOptInfo::partition_qual, RelOptInfo::pathlist, QualCost::per_tuple, RelOptInfo::ppilist, RelOptInfo::rel_parallel_workers, RelOptInfo::relid, RelOptInfo::relids, RELOPT_BASEREL, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::rows, RTE_CTE, RTE_FUNCTION, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RelOptInfo::rtekind, RelOptInfo::serverid, QualCost::startup, RelOptInfo::statlist, RelOptInfo::subplan_params, RelOptInfo::subroot, RelOptInfo::top_parent_relids, RelOptInfo::tuples, RelOptInfo::unique_for_rels, RelOptInfo::userid, and RelOptInfo::useridiscurrent.

Referenced by add_base_rels_to_query(), expand_appendrel_subquery(), expand_inherited_rtentry(), expand_partitioned_rtentry(), plan_cluster_use_sort(), plan_create_index_workers(), query_planner(), and recurse_set_operations().

calc_nestloop_required_outer()

Relids calc_nestloop_required_outer	(	Relids	outerrelids,
		Relids	outer_paramrels,
		Relids	innerrelids,
		Relids	inner_paramrels
	)

Definition at line 2456 of file pathnode.c.

{
    Relids      required_outer;
 
    /* inner_path can require rels from outer path, but not vice versa */
    Assert(!bms_overlap(outer_paramrels, innerrelids));
    /* easy case if inner path is not parameterized */
    if (!inner_paramrels)
        return bms_copy(outer_paramrels);
    /* else, form the union ... */
    required_outer = bms_union(outer_paramrels, inner_paramrels);
    /* ... and remove any mention of now-satisfied outer rels */
    required_outer = bms_del_members(required_outer,
                                     outerrelids);
    return required_outer;
}

References Assert(), bms_copy(), bms_del_members(), bms_overlap(), and bms_union().

Referenced by try_nestloop_path().

calc_non_nestloop_required_outer()

Relids calc_non_nestloop_required_outer	(	Path *	outer_path,
		Path *	inner_path
	)

Definition at line 2483 of file pathnode.c.

{
    Relids      outer_paramrels = PATH_REQ_OUTER(outer_path);
    Relids      inner_paramrels = PATH_REQ_OUTER(inner_path);
    Relids      innerrelids PG_USED_FOR_ASSERTS_ONLY;
    Relids      outerrelids PG_USED_FOR_ASSERTS_ONLY;
    Relids      required_outer;
 
    /*
     * Any parameterization of the input paths refers to topmost parents of
     * the relevant relations, because reparameterize_path_by_child() hasn't
     * been called yet.  So we must consider topmost parents of the relations
     * being joined, too, while checking for disallowed parameterization
     * cases.
     */
    if (inner_path->parent->top_parent_relids)
        innerrelids = inner_path->parent->top_parent_relids;
    else
        innerrelids = inner_path->parent->relids;
 
    if (outer_path->parent->top_parent_relids)
        outerrelids = outer_path->parent->top_parent_relids;
    else
        outerrelids = outer_path->parent->relids;
 
    /* neither path can require rels from the other */
    Assert(!bms_overlap(outer_paramrels, innerrelids));
    Assert(!bms_overlap(inner_paramrels, outerrelids));
    /* form the union ... */
    required_outer = bms_union(outer_paramrels, inner_paramrels);
    /* we do not need an explicit test for empty; bms_union gets it right */
    return required_outer;
}

References Assert(), bms_overlap(), bms_union(), PATH_REQ_OUTER, and PG_USED_FOR_ASSERTS_ONLY.

Referenced by try_hashjoin_path(), and try_mergejoin_path().

compare_fractional_path_costs()

int compare_fractional_path_costs	(	Path *	path1,
		Path *	path2,
		double	fraction
	)

Definition at line 124 of file pathnode.c.

{
    Cost        cost1,
                cost2;
 
    /* Number of disabled nodes, if different, trumps all else. */
    if (unlikely(path1->disabled_nodes != path2->disabled_nodes))
    {
        if (path1->disabled_nodes < path2->disabled_nodes)
            return -1;
        else
            return +1;
    }
 
    if (fraction <= 0.0 || fraction >= 1.0)
        return compare_path_costs(path1, path2, TOTAL_COST);
    cost1 = path1->startup_cost +
        fraction * (path1->total_cost - path1->startup_cost);
    cost2 = path2->startup_cost +
        fraction * (path2->total_cost - path2->startup_cost);
    if (cost1 < cost2)
        return -1;
    if (cost1 > cost2)
        return +1;
    return 0;
}

References compare_path_costs(), Path::disabled_nodes, Path::startup_cost, TOTAL_COST, Path::total_cost, and unlikely.

Referenced by get_cheapest_fractional_path(), and get_cheapest_fractional_path_for_pathkeys().

compare_path_costs()

int compare_path_costs	(	Path *	path1,
		Path *	path2,
		CostSelector	criterion
	)

Definition at line 69 of file pathnode.c.

{
    /* Number of disabled nodes, if different, trumps all else. */
    if (unlikely(path1->disabled_nodes != path2->disabled_nodes))
    {
        if (path1->disabled_nodes < path2->disabled_nodes)
            return -1;
        else
            return +1;
    }
 
    if (criterion == STARTUP_COST)
    {
        if (path1->startup_cost < path2->startup_cost)
            return -1;
        if (path1->startup_cost > path2->startup_cost)
            return +1;
 
        /*
         * If paths have the same startup cost (not at all unlikely), order
         * them by total cost.
         */
        if (path1->total_cost < path2->total_cost)
            return -1;
        if (path1->total_cost > path2->total_cost)
            return +1;
    }
    else
    {
        if (path1->total_cost < path2->total_cost)
            return -1;
        if (path1->total_cost > path2->total_cost)
            return +1;
 
        /*
         * If paths have the same total cost, order them by startup cost.
         */
        if (path1->startup_cost < path2->startup_cost)
            return -1;
        if (path1->startup_cost > path2->startup_cost)
            return +1;
    }
    return 0;
}

References Path::disabled_nodes, STARTUP_COST, Path::startup_cost, Path::total_cost, and unlikely.

Referenced by append_startup_cost_compare(), append_total_cost_compare(), compare_fractional_path_costs(), generate_mergejoin_paths(), get_cheapest_parameterized_child_path(), get_cheapest_path_for_pathkeys(), and set_cheapest().

create_agg_path()

AggPath * create_agg_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target,
		AggStrategy	aggstrategy,
		AggSplit	aggsplit,
		List *	groupClause,
		List *	qual,
		const AggClauseCosts *	aggcosts,
		double	numGroups
	)

Definition at line 3243 of file pathnode.c.

{
    AggPath    *pathnode = makeNode(AggPath);
 
    pathnode->path.pathtype = T_Agg;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
 
    if (aggstrategy == AGG_SORTED)
    {
        /*
         * Attempt to preserve the order of the subpath.  Additional pathkeys
         * may have been added in adjust_group_pathkeys_for_groupagg() to
         * support ORDER BY / DISTINCT aggregates.  Pathkeys added there
         * belong to columns within the aggregate function, so we must strip
         * these additional pathkeys off as those columns are unavailable
         * above the aggregate node.
         */
        if (list_length(subpath->pathkeys) > root->num_groupby_pathkeys)
            pathnode->path.pathkeys = list_copy_head(subpath->pathkeys,
                                                     root->num_groupby_pathkeys);
        else
            pathnode->path.pathkeys = subpath->pathkeys;    /* preserves order */
    }
    else
        pathnode->path.pathkeys = NIL;  /* output is unordered */
 
    pathnode->subpath = subpath;
 
    pathnode->aggstrategy = aggstrategy;
    pathnode->aggsplit = aggsplit;
    pathnode->numGroups = numGroups;
    pathnode->transitionSpace = aggcosts ? aggcosts->transitionSpace : 0;
    pathnode->groupClause = groupClause;
    pathnode->qual = qual;
 
    cost_agg(&pathnode->path, root,
             aggstrategy, aggcosts,
             list_length(groupClause), numGroups,
             qual,
             subpath->disabled_nodes,
             subpath->startup_cost, subpath->total_cost,
             subpath->rows, subpath->pathtarget->width);
 
    /* add tlist eval cost for each output row */
    pathnode->path.startup_cost += target->cost.startup;
    pathnode->path.total_cost += target->cost.startup +
        target->cost.per_tuple * pathnode->path.rows;
 
    return pathnode;
}

References AGG_SORTED, AggPath::aggsplit, AggPath::aggstrategy, RelOptInfo::consider_parallel, PathTarget::cost, cost_agg(), AggPath::groupClause, list_copy_head(), list_length(), makeNode, NIL, AggPath::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, AggPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, AggPath::qual, root, Path::rows, QualCost::startup, Path::startup_cost, subpath(), AggPath::subpath, Path::total_cost, AggClauseCosts::transitionSpace, and AggPath::transitionSpace.

Referenced by add_paths_to_grouping_rel(), create_final_distinct_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), and generate_union_paths().

create_append_path()

AppendPath * create_append_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	subpaths,
		List *	partial_subpaths,
		List *	pathkeys,
		Relids	required_outer,
		int	parallel_workers,
		bool	parallel_aware,
		double	rows
	)

Definition at line 1300 of file pathnode.c.

{
    AppendPath *pathnode = makeNode(AppendPath);
    ListCell   *l;
 
    Assert(!parallel_aware || parallel_workers > 0);
 
    pathnode->path.pathtype = T_Append;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
 
    /*
     * If this is for a baserel (not a join or non-leaf partition), we prefer
     * to apply get_baserel_parampathinfo to construct a full ParamPathInfo
     * for the path.  This supports building a Memoize path atop this path,
     * and if this is a partitioned table the info may be useful for run-time
     * pruning (cf make_partition_pruneinfo()).
     *
     * However, if we don't have "root" then that won't work and we fall back
     * on the simpler get_appendrel_parampathinfo.  There's no point in doing
     * the more expensive thing for a dummy path, either.
     */
    if (rel->reloptkind == RELOPT_BASEREL && root && subpaths != NIL)
        pathnode->path.param_info = get_baserel_parampathinfo(root,
                                                              rel,
                                                              required_outer);
    else
        pathnode->path.param_info = get_appendrel_parampathinfo(rel,
                                                                required_outer);
 
    pathnode->path.parallel_aware = parallel_aware;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = parallel_workers;
    pathnode->path.pathkeys = pathkeys;
 
    /*
     * For parallel append, non-partial paths are sorted by descending total
     * costs. That way, the total time to finish all non-partial paths is
     * minimized.  Also, the partial paths are sorted by descending startup
     * costs.  There may be some paths that require to do startup work by a
     * single worker.  In such case, it's better for workers to choose the
     * expensive ones first, whereas the leader should choose the cheapest
     * startup plan.
     */
    if (pathnode->path.parallel_aware)
    {
        /*
         * We mustn't fiddle with the order of subpaths when the Append has
         * pathkeys.  The order they're listed in is critical to keeping the
         * pathkeys valid.
         */
        Assert(pathkeys == NIL);
 
        list_sort(subpaths, append_total_cost_compare);
        list_sort(partial_subpaths, append_startup_cost_compare);
    }
    pathnode->first_partial_path = list_length(subpaths);
    pathnode->subpaths = list_concat(subpaths, partial_subpaths);
 
    /*
     * Apply query-wide LIMIT if known and path is for sole base relation.
     * (Handling this at this low level is a bit klugy.)
     */
    if (root != NULL && bms_equal(rel->relids, root->all_query_rels))
        pathnode->limit_tuples = root->limit_tuples;
    else
        pathnode->limit_tuples = -1.0;
 
    foreach(l, pathnode->subpaths)
    {
        Path       *subpath = (Path *) lfirst(l);
 
        pathnode->path.parallel_safe = pathnode->path.parallel_safe &&
            subpath->parallel_safe;
 
        /* All child paths must have same parameterization */
        Assert(bms_equal(PATH_REQ_OUTER(subpath), required_outer));
    }
 
    Assert(!parallel_aware || pathnode->path.parallel_safe);
 
    /*
     * If there's exactly one child path then the output of the Append is
     * necessarily ordered the same as the child's, so we can inherit the
     * child's pathkeys if any, overriding whatever the caller might've said.
     * Furthermore, if the child's parallel awareness matches the Append's,
     * then the Append is a no-op and will be discarded later (in setrefs.c).
     * Then we can inherit the child's size and cost too, effectively charging
     * zero for the Append.  Otherwise, we must do the normal costsize
     * calculation.
     */
    if (list_length(pathnode->subpaths) == 1)
    {
        Path       *child = (Path *) linitial(pathnode->subpaths);
 
        if (child->parallel_aware == parallel_aware)
        {
            pathnode->path.rows = child->rows;
            pathnode->path.startup_cost = child->startup_cost;
            pathnode->path.total_cost = child->total_cost;
        }
        else
            cost_append(pathnode);
        /* Must do this last, else cost_append complains */
        pathnode->path.pathkeys = child->pathkeys;
    }
    else
        cost_append(pathnode);
 
    /* If the caller provided a row estimate, override the computed value. */
    if (rows >= 0)
        pathnode->path.rows = rows;
 
    return pathnode;
}

References append_startup_cost_compare(), append_total_cost_compare(), Assert(), bms_equal(), RelOptInfo::consider_parallel, cost_append(), AppendPath::first_partial_path, get_appendrel_parampathinfo(), get_baserel_parampathinfo(), lfirst, AppendPath::limit_tuples, linitial, list_concat(), list_length(), list_sort(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, AppendPath::path, PATH_REQ_OUTER, Path::pathkeys, Path::pathtype, RelOptInfo::relids, RELOPT_BASEREL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, Path::rows, Path::startup_cost, subpath(), AppendPath::subpaths, and Path::total_cost.

Referenced by add_paths_to_append_rel(), create_degenerate_grouping_paths(), generate_orderedappend_paths(), generate_union_paths(), mark_dummy_rel(), reparameterize_path(), and set_dummy_rel_pathlist().

create_bitmap_and_path()

BitmapAndPath * create_bitmap_and_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	bitmapquals
	)

Definition at line 1131 of file pathnode.c.

{
    BitmapAndPath *pathnode = makeNode(BitmapAndPath);
    Relids      required_outer = NULL;
    ListCell   *lc;
 
    pathnode->path.pathtype = T_BitmapAnd;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
 
    /*
     * Identify the required outer rels as the union of what the child paths
     * depend on.  (Alternatively, we could insist that the caller pass this
     * in, but it's more convenient and reliable to compute it here.)
     */
    foreach(lc, bitmapquals)
    {
        Path       *bitmapqual = (Path *) lfirst(lc);
 
        required_outer = bms_add_members(required_outer,
                                         PATH_REQ_OUTER(bitmapqual));
    }
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
 
    /*
     * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be
     * parallel-safe if and only if rel->consider_parallel is set.  So, we can
     * set the flag for this path based only on the relation-level flag,
     * without actually iterating over the list of children.
     */
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
 
    pathnode->path.pathkeys = NIL;  /* always unordered */
 
    pathnode->bitmapquals = bitmapquals;
 
    /* this sets bitmapselectivity as well as the regular cost fields: */
    cost_bitmap_and_node(pathnode, root);
 
    return pathnode;
}

References BitmapAndPath::bitmapquals, bms_add_members(), RelOptInfo::consider_parallel, cost_bitmap_and_node(), get_baserel_parampathinfo(), lfirst, makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, BitmapAndPath::path, PATH_REQ_OUTER, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by bitmap_and_cost_est(), and choose_bitmap_and().

create_bitmap_heap_path()

BitmapHeapPath * create_bitmap_heap_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	bitmapqual,
		Relids	required_outer,
		double	loop_count,
		int	parallel_degree
	)

Definition at line 1098 of file pathnode.c.

{
    BitmapHeapPath *pathnode = makeNode(BitmapHeapPath);
 
    pathnode->path.pathtype = T_BitmapHeapScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = (parallel_degree > 0);
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = parallel_degree;
    pathnode->path.pathkeys = NIL;  /* always unordered */
 
    pathnode->bitmapqual = bitmapqual;
 
    cost_bitmap_heap_scan(&pathnode->path, root, rel,
                          pathnode->path.param_info,
                          bitmapqual, loop_count);
 
    return pathnode;
}

References BitmapHeapPath::bitmapqual, RelOptInfo::consider_parallel, cost_bitmap_heap_scan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, BitmapHeapPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by create_index_paths(), create_partial_bitmap_paths(), and reparameterize_path().

create_bitmap_or_path()

BitmapOrPath * create_bitmap_or_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	bitmapquals
	)

Definition at line 1183 of file pathnode.c.

{
    BitmapOrPath *pathnode = makeNode(BitmapOrPath);
    Relids      required_outer = NULL;
    ListCell   *lc;
 
    pathnode->path.pathtype = T_BitmapOr;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
 
    /*
     * Identify the required outer rels as the union of what the child paths
     * depend on.  (Alternatively, we could insist that the caller pass this
     * in, but it's more convenient and reliable to compute it here.)
     */
    foreach(lc, bitmapquals)
    {
        Path       *bitmapqual = (Path *) lfirst(lc);
 
        required_outer = bms_add_members(required_outer,
                                         PATH_REQ_OUTER(bitmapqual));
    }
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
 
    /*
     * Currently, a BitmapHeapPath, BitmapAndPath, or BitmapOrPath will be
     * parallel-safe if and only if rel->consider_parallel is set.  So, we can
     * set the flag for this path based only on the relation-level flag,
     * without actually iterating over the list of children.
     */
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
 
    pathnode->path.pathkeys = NIL;  /* always unordered */
 
    pathnode->bitmapquals = bitmapquals;
 
    /* this sets bitmapselectivity as well as the regular cost fields: */
    cost_bitmap_or_node(pathnode, root);
 
    return pathnode;
}

References BitmapOrPath::bitmapquals, bms_add_members(), RelOptInfo::consider_parallel, cost_bitmap_or_node(), get_baserel_parampathinfo(), lfirst, makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, BitmapOrPath::path, PATH_REQ_OUTER, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by generate_bitmap_or_paths().

create_ctescan_path()

Path * create_ctescan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 2196 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_CteScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = pathkeys;
 
    cost_ctescan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_ctescan(), get_baserel_parampathinfo(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_cte_pathlist().

create_foreign_join_path()

ForeignPath * create_foreign_join_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		PathTarget *	target,
		double	rows,
		int	disabled_nodes,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Relids	required_outer,
		Path *	fdw_outerpath,
		List *	fdw_restrictinfo,
		List *	fdw_private
	)

Definition at line 2355 of file pathnode.c.

{
    ForeignPath *pathnode = makeNode(ForeignPath);
 
    /*
     * We should use get_joinrel_parampathinfo to handle parameterized paths,
     * but the API of this function doesn't support it, and existing
     * extensions aren't yet trying to build such paths anyway.  For the
     * moment just throw an error if someone tries it; eventually we should
     * revisit this.
     */
    if (!bms_is_empty(required_outer) || !bms_is_empty(rel->lateral_relids))
        elog(ERROR, "parameterized foreign joins are not supported yet");
 
    pathnode->path.pathtype = T_ForeignScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target ? target : rel->reltarget;
    pathnode->path.param_info = NULL;   /* XXX see above */
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.rows = rows;
    pathnode->path.disabled_nodes = disabled_nodes;
    pathnode->path.startup_cost = startup_cost;
    pathnode->path.total_cost = total_cost;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->fdw_outerpath = fdw_outerpath;
    pathnode->fdw_restrictinfo = fdw_restrictinfo;
    pathnode->fdw_private = fdw_private;
 
    return pathnode;
}

References bms_is_empty, RelOptInfo::consider_parallel, Path::disabled_nodes, elog, ERROR, ForeignPath::fdw_outerpath, ForeignPath::fdw_private, ForeignPath::fdw_restrictinfo, RelOptInfo::lateral_relids, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ForeignPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by add_paths_with_pathkeys_for_rel(), and postgresGetForeignJoinPaths().

create_foreign_upper_path()

ForeignPath * create_foreign_upper_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		PathTarget *	target,
		double	rows,
		int	disabled_nodes,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Path *	fdw_outerpath,
		List *	fdw_restrictinfo,
		List *	fdw_private
	)

Definition at line 2409 of file pathnode.c.

{
    ForeignPath *pathnode = makeNode(ForeignPath);
 
    /*
     * Upper relations should never have any lateral references, since joining
     * is complete.
     */
    Assert(bms_is_empty(rel->lateral_relids));
 
    pathnode->path.pathtype = T_ForeignScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target ? target : rel->reltarget;
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.rows = rows;
    pathnode->path.disabled_nodes = disabled_nodes;
    pathnode->path.startup_cost = startup_cost;
    pathnode->path.total_cost = total_cost;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->fdw_outerpath = fdw_outerpath;
    pathnode->fdw_restrictinfo = fdw_restrictinfo;
    pathnode->fdw_private = fdw_private;
 
    return pathnode;
}

References Assert(), bms_is_empty, RelOptInfo::consider_parallel, Path::disabled_nodes, ForeignPath::fdw_outerpath, ForeignPath::fdw_private, ForeignPath::fdw_restrictinfo, RelOptInfo::lateral_relids, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ForeignPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by add_foreign_final_paths(), add_foreign_grouping_paths(), and add_foreign_ordered_paths().

create_foreignscan_path()

ForeignPath * create_foreignscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		PathTarget *	target,
		double	rows,
		int	disabled_nodes,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Relids	required_outer,
		Path *	fdw_outerpath,
		List *	fdw_restrictinfo,
		List *	fdw_private
	)

Definition at line 2307 of file pathnode.c.

{
    ForeignPath *pathnode = makeNode(ForeignPath);
 
    /* Historically some FDWs were confused about when to use this */
    Assert(IS_SIMPLE_REL(rel));
 
    pathnode->path.pathtype = T_ForeignScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target ? target : rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.rows = rows;
    pathnode->path.disabled_nodes = disabled_nodes;
    pathnode->path.startup_cost = startup_cost;
    pathnode->path.total_cost = total_cost;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->fdw_outerpath = fdw_outerpath;
    pathnode->fdw_restrictinfo = fdw_restrictinfo;
    pathnode->fdw_private = fdw_private;
 
    return pathnode;
}

References Assert(), RelOptInfo::consider_parallel, Path::disabled_nodes, ForeignPath::fdw_outerpath, ForeignPath::fdw_private, ForeignPath::fdw_restrictinfo, get_baserel_parampathinfo(), IS_SIMPLE_REL, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ForeignPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, root, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by add_paths_with_pathkeys_for_rel(), fileGetForeignPaths(), and postgresGetForeignPaths().

create_functionscan_path()

Path * create_functionscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 2118 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_FunctionScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = pathkeys;
 
    cost_functionscan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_functionscan(), get_baserel_parampathinfo(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_function_pathlist().

create_gather_merge_path()

GatherMergePath * create_gather_merge_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target,
		List *	pathkeys,
		Relids	required_outer,
		double *	rows
	)

Definition at line 1962 of file pathnode.c.

{
    GatherMergePath *pathnode = makeNode(GatherMergePath);
    int         input_disabled_nodes = 0;
    Cost        input_startup_cost = 0;
    Cost        input_total_cost = 0;
 
    Assert(subpath->parallel_safe);
    Assert(pathkeys);
 
    /*
     * The subpath should guarantee that it is adequately ordered either by
     * adding an explicit sort node or by using presorted input.  We cannot
     * add an explicit Sort node for the subpath in createplan.c on additional
     * pathkeys, because we can't guarantee the sort would be safe.  For
     * example, expressions may be volatile or otherwise parallel unsafe.
     */
    if (!pathkeys_contained_in(pathkeys, subpath->pathkeys))
        elog(ERROR, "gather merge input not sufficiently sorted");
 
    pathnode->path.pathtype = T_GatherMerge;
    pathnode->path.parent = rel;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
 
    pathnode->subpath = subpath;
    pathnode->num_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = pathkeys;
    pathnode->path.pathtarget = target ? target : rel->reltarget;
 
    input_disabled_nodes += subpath->disabled_nodes;
    input_startup_cost += subpath->startup_cost;
    input_total_cost += subpath->total_cost;
 
    cost_gather_merge(pathnode, root, rel, pathnode->path.param_info,
                      input_disabled_nodes, input_startup_cost,
                      input_total_cost, rows);
 
    return pathnode;
}

References Assert(), cost_gather_merge(), elog, ERROR, get_baserel_parampathinfo(), makeNode, GatherMergePath::num_workers, Path::parallel_aware, GatherMergePath::path, Path::pathkeys, pathkeys_contained_in(), Path::pathtype, RelOptInfo::reltarget, root, subpath(), and GatherMergePath::subpath.

Referenced by create_ordered_paths(), gather_grouping_paths(), generate_gather_paths(), and generate_useful_gather_paths().

create_gather_path()

GatherPath * create_gather_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target,
		Relids	required_outer,
		double *	rows
	)

Definition at line 2044 of file pathnode.c.

{
    GatherPath *pathnode = makeNode(GatherPath);
 
    Assert(subpath->parallel_safe);
 
    pathnode->path.pathtype = T_Gather;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = false;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = NIL;  /* Gather has unordered result */
 
    pathnode->subpath = subpath;
    pathnode->num_workers = subpath->parallel_workers;
    pathnode->single_copy = false;
 
    if (pathnode->num_workers == 0)
    {
        pathnode->path.pathkeys = subpath->pathkeys;
        pathnode->num_workers = 1;
        pathnode->single_copy = true;
    }
 
    cost_gather(pathnode, root, rel, pathnode->path.param_info, rows);
 
    return pathnode;
}

References Assert(), cost_gather(), get_baserel_parampathinfo(), makeNode, NIL, GatherPath::num_workers, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, GatherPath::path, Path::pathkeys, Path::pathtype, root, GatherPath::single_copy, subpath(), and GatherPath::subpath.

Referenced by generate_gather_paths(), and generate_union_paths().

create_group_path()

GroupPath * create_group_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	groupClause,
		List *	qual,
		double	numGroups
	)

Definition at line 3130 of file pathnode.c.

{
    GroupPath  *pathnode = makeNode(GroupPath);
    PathTarget *target = rel->reltarget;
 
    pathnode->path.pathtype = T_Group;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    /* Group doesn't change sort ordering */
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
 
    pathnode->groupClause = groupClause;
    pathnode->qual = qual;
 
    cost_group(&pathnode->path, root,
               list_length(groupClause),
               numGroups,
               qual,
               subpath->disabled_nodes,
               subpath->startup_cost, subpath->total_cost,
               subpath->rows);
 
    /* add tlist eval cost for each output row */
    pathnode->path.startup_cost += target->cost.startup;
    pathnode->path.total_cost += target->cost.startup +
        target->cost.per_tuple * pathnode->path.rows;
 
    return pathnode;
}

References RelOptInfo::consider_parallel, PathTarget::cost, cost_group(), GroupPath::groupClause, list_length(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, GroupPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, GroupPath::qual, RelOptInfo::reltarget, root, Path::rows, QualCost::startup, Path::startup_cost, subpath(), GroupPath::subpath, and Path::total_cost.

Referenced by add_paths_to_grouping_rel(), and create_partial_grouping_paths().

create_group_result_path()

GroupResultPath * create_group_result_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		PathTarget *	target,
		List *	havingqual
	)

Definition at line 1586 of file pathnode.c.

{
    GroupResultPath *pathnode = makeNode(GroupResultPath);
 
    pathnode->path.pathtype = T_Result;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    pathnode->path.param_info = NULL;   /* there are no other rels... */
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = NIL;
    pathnode->quals = havingqual;
 
    /*
     * We can't quite use cost_resultscan() because the quals we want to
     * account for are not baserestrict quals of the rel.  Might as well just
     * hack it here.
     */
    pathnode->path.rows = 1;
    pathnode->path.startup_cost = target->cost.startup;
    pathnode->path.total_cost = target->cost.startup +
        cpu_tuple_cost + target->cost.per_tuple;
 
    /*
     * Add cost of qual, if any --- but we ignore its selectivity, since our
     * rowcount estimate should be 1 no matter what the qual is.
     */
    if (havingqual)
    {
        QualCost    qual_cost;
 
        cost_qual_eval(&qual_cost, havingqual, root);
        /* havingqual is evaluated once at startup */
        pathnode->path.startup_cost += qual_cost.startup + qual_cost.per_tuple;
        pathnode->path.total_cost += qual_cost.startup + qual_cost.per_tuple;
    }
 
    return pathnode;
}

References RelOptInfo::consider_parallel, PathTarget::cost, cost_qual_eval(), cpu_tuple_cost, makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, GroupResultPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, GroupResultPath::quals, root, Path::rows, QualCost::startup, Path::startup_cost, and Path::total_cost.

Referenced by create_degenerate_grouping_paths(), and query_planner().

create_groupingsets_path()

GroupingSetsPath * create_groupingsets_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	having_qual,
		AggStrategy	aggstrategy,
		List *	rollups,
		const AggClauseCosts *	agg_costs
	)

Definition at line 3326 of file pathnode.c.

{
    GroupingSetsPath *pathnode = makeNode(GroupingSetsPath);
    PathTarget *target = rel->reltarget;
    ListCell   *lc;
    bool        is_first = true;
    bool        is_first_sort = true;
 
    /* The topmost generated Plan node will be an Agg */
    pathnode->path.pathtype = T_Agg;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    pathnode->path.param_info = subpath->param_info;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->subpath = subpath;
 
    /*
     * Simplify callers by downgrading AGG_SORTED to AGG_PLAIN, and AGG_MIXED
     * to AGG_HASHED, here if possible.
     */
    if (aggstrategy == AGG_SORTED &&
        list_length(rollups) == 1 &&
        ((RollupData *) linitial(rollups))->groupClause == NIL)
        aggstrategy = AGG_PLAIN;
 
    if (aggstrategy == AGG_MIXED &&
        list_length(rollups) == 1)
        aggstrategy = AGG_HASHED;
 
    /*
     * Output will be in sorted order by group_pathkeys if, and only if, there
     * is a single rollup operation on a non-empty list of grouping
     * expressions.
     */
    if (aggstrategy == AGG_SORTED && list_length(rollups) == 1)
        pathnode->path.pathkeys = root->group_pathkeys;
    else
        pathnode->path.pathkeys = NIL;
 
    pathnode->aggstrategy = aggstrategy;
    pathnode->rollups = rollups;
    pathnode->qual = having_qual;
    pathnode->transitionSpace = agg_costs ? agg_costs->transitionSpace : 0;
 
    Assert(rollups != NIL);
    Assert(aggstrategy != AGG_PLAIN || list_length(rollups) == 1);
    Assert(aggstrategy != AGG_MIXED || list_length(rollups) > 1);
 
    foreach(lc, rollups)
    {
        RollupData *rollup = lfirst(lc);
        List       *gsets = rollup->gsets;
        int         numGroupCols = list_length(linitial(gsets));
 
        /*
         * In AGG_SORTED or AGG_PLAIN mode, the first rollup takes the
         * (already-sorted) input, and following ones do their own sort.
         *
         * In AGG_HASHED mode, there is one rollup for each grouping set.
         *
         * In AGG_MIXED mode, the first rollups are hashed, the first
         * non-hashed one takes the (already-sorted) input, and following ones
         * do their own sort.
         */
        if (is_first)
        {
            cost_agg(&pathnode->path, root,
                     aggstrategy,
                     agg_costs,
                     numGroupCols,
                     rollup->numGroups,
                     having_qual,
                     subpath->disabled_nodes,
                     subpath->startup_cost,
                     subpath->total_cost,
                     subpath->rows,
                     subpath->pathtarget->width);
            is_first = false;
            if (!rollup->is_hashed)
                is_first_sort = false;
        }
        else
        {
            Path        sort_path;  /* dummy for result of cost_sort */
            Path        agg_path;   /* dummy for result of cost_agg */
 
            if (rollup->is_hashed || is_first_sort)
            {
                /*
                 * Account for cost of aggregation, but don't charge input
                 * cost again
                 */
                cost_agg(&agg_path, root,
                         rollup->is_hashed ? AGG_HASHED : AGG_SORTED,
                         agg_costs,
                         numGroupCols,
                         rollup->numGroups,
                         having_qual,
                         0, 0.0, 0.0,
                         subpath->rows,
                         subpath->pathtarget->width);
                if (!rollup->is_hashed)
                    is_first_sort = false;
            }
            else
            {
                /* Account for cost of sort, but don't charge input cost again */
                cost_sort(&sort_path, root, NIL, 0,
                          0.0,
                          subpath->rows,
                          subpath->pathtarget->width,
                          0.0,
                          work_mem,
                          -1.0);
 
                /* Account for cost of aggregation */
 
                cost_agg(&agg_path, root,
                         AGG_SORTED,
                         agg_costs,
                         numGroupCols,
                         rollup->numGroups,
                         having_qual,
                         sort_path.disabled_nodes,
                         sort_path.startup_cost,
                         sort_path.total_cost,
                         sort_path.rows,
                         subpath->pathtarget->width);
            }
 
            pathnode->path.disabled_nodes += agg_path.disabled_nodes;
            pathnode->path.total_cost += agg_path.total_cost;
            pathnode->path.rows += agg_path.rows;
        }
    }
 
    /* add tlist eval cost for each output row */
    pathnode->path.startup_cost += target->cost.startup;
    pathnode->path.total_cost += target->cost.startup +
        target->cost.per_tuple * pathnode->path.rows;
 
    return pathnode;
}

References AGG_HASHED, AGG_MIXED, AGG_PLAIN, AGG_SORTED, GroupingSetsPath::aggstrategy, Assert(), RelOptInfo::consider_parallel, PathTarget::cost, cost_agg(), cost_sort(), Path::disabled_nodes, RollupData::gsets, RollupData::is_hashed, lfirst, linitial, list_length(), makeNode, NIL, RollupData::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, GroupingSetsPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, GroupingSetsPath::qual, RelOptInfo::reltarget, GroupingSetsPath::rollups, root, Path::rows, QualCost::startup, Path::startup_cost, subpath(), GroupingSetsPath::subpath, Path::total_cost, AggClauseCosts::transitionSpace, GroupingSetsPath::transitionSpace, and work_mem.

Referenced by consider_groupingsets_paths().

create_hashjoin_path()

HashPath * create_hashjoin_path	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		JoinType	jointype,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra,
		Path *	outer_path,
		Path *	inner_path,
		bool	parallel_hash,
		List *	restrict_clauses,
		Relids	required_outer,
		List *	hashclauses
	)

Definition at line 2700 of file pathnode.c.

{
    HashPath   *pathnode = makeNode(HashPath);
 
    pathnode->jpath.path.pathtype = T_HashJoin;
    pathnode->jpath.path.parent = joinrel;
    pathnode->jpath.path.pathtarget = joinrel->reltarget;
    pathnode->jpath.path.param_info =
        get_joinrel_parampathinfo(root,
                                  joinrel,
                                  outer_path,
                                  inner_path,
                                  extra->sjinfo,
                                  required_outer,
                                  &restrict_clauses);
    pathnode->jpath.path.parallel_aware =
        joinrel->consider_parallel && parallel_hash;
    pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
        outer_path->parallel_safe && inner_path->parallel_safe;
    /* This is a foolish way to estimate parallel_workers, but for now... */
    pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
 
    /*
     * A hashjoin never has pathkeys, since its output ordering is
     * unpredictable due to possible batching.  XXX If the inner relation is
     * small enough, we could instruct the executor that it must not batch,
     * and then we could assume that the output inherits the outer relation's
     * ordering, which might save a sort step.  However there is considerable
     * downside if our estimate of the inner relation size is badly off. For
     * the moment we don't risk it.  (Note also that if we wanted to take this
     * seriously, joinpath.c would have to consider many more paths for the
     * outer rel than it does now.)
     */
    pathnode->jpath.path.pathkeys = NIL;
    pathnode->jpath.jointype = jointype;
    pathnode->jpath.inner_unique = extra->inner_unique;
    pathnode->jpath.outerjoinpath = outer_path;
    pathnode->jpath.innerjoinpath = inner_path;
    pathnode->jpath.joinrestrictinfo = restrict_clauses;
    pathnode->path_hashclauses = hashclauses;
    /* final_cost_hashjoin will fill in pathnode->num_batches */
 
    final_cost_hashjoin(root, pathnode, workspace, extra);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, final_cost_hashjoin(), get_joinrel_parampathinfo(), JoinPath::inner_unique, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, JoinPath::joinrestrictinfo, JoinPath::jointype, HashPath::jpath, makeNode, NIL, JoinPath::outerjoinpath, Path::parallel_safe, Path::parallel_workers, HashPath::path_hashclauses, RelOptInfo::reltarget, root, and JoinPathExtraData::sjinfo.

Referenced by try_hashjoin_path(), and try_partial_hashjoin_path().

create_incremental_sort_path()

IncrementalSortPath * create_incremental_sort_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	pathkeys,
		int	presorted_keys,
		double	limit_tuples
	)

Definition at line 3035 of file pathnode.c.

{
    IncrementalSortPath *sort = makeNode(IncrementalSortPath);
    SortPath   *pathnode = &sort->spath;
 
    pathnode->path.pathtype = T_IncrementalSort;
    pathnode->path.parent = rel;
    /* Sort doesn't project, so use source path's pathtarget */
    pathnode->path.pathtarget = subpath->pathtarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->subpath = subpath;
 
    cost_incremental_sort(&pathnode->path,
                          root, pathkeys, presorted_keys,
                          subpath->disabled_nodes,
                          subpath->startup_cost,
                          subpath->total_cost,
                          subpath->rows,
                          subpath->pathtarget->width,
                          0.0,  /* XXX comparison_cost shouldn't be 0? */
                          work_mem, limit_tuples);
 
    sort->nPresortedCols = presorted_keys;
 
    return sort;
}

References RelOptInfo::consider_parallel, cost_incremental_sort(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, SortPath::path, Path::pathkeys, Path::pathtype, root, sort(), subpath(), SortPath::subpath, and work_mem.

Referenced by build_setop_child_paths(), create_one_window_path(), create_ordered_paths(), gather_grouping_paths(), generate_useful_gather_paths(), and make_ordered_path().

create_index_path()

IndexPath * create_index_path	(	PlannerInfo *	root,
		IndexOptInfo *	index,
		List *	indexclauses,
		List *	indexorderbys,
		List *	indexorderbycols,
		List *	pathkeys,
		ScanDirection	indexscandir,
		bool	indexonly,
		Relids	required_outer,
		double	loop_count,
		bool	partial_path
	)

Definition at line 1049 of file pathnode.c.

{
    IndexPath  *pathnode = makeNode(IndexPath);
    RelOptInfo *rel = index->rel;
 
    pathnode->path.pathtype = indexonly ? T_IndexOnlyScan : T_IndexScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->indexinfo = index;
    pathnode->indexclauses = indexclauses;
    pathnode->indexorderbys = indexorderbys;
    pathnode->indexorderbycols = indexorderbycols;
    pathnode->indexscandir = indexscandir;
 
    cost_index(pathnode, root, loop_count, partial_path);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_index(), get_baserel_parampathinfo(), IndexPath::indexclauses, IndexPath::indexinfo, IndexPath::indexorderbycols, IndexPath::indexorderbys, IndexPath::indexscandir, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, IndexPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by build_index_paths(), and plan_cluster_use_sort().

create_limit_path()

LimitPath * create_limit_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		Node *	limitOffset,
		Node *	limitCount,
		LimitOption	limitOption,
		int64	offset_est,
		int64	count_est
	)

Definition at line 3982 of file pathnode.c.

{
    LimitPath  *pathnode = makeNode(LimitPath);
 
    pathnode->path.pathtype = T_Limit;
    pathnode->path.parent = rel;
    /* Limit doesn't project, so use source path's pathtarget */
    pathnode->path.pathtarget = subpath->pathtarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.rows = subpath->rows;
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
    pathnode->path.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost;
    pathnode->path.pathkeys = subpath->pathkeys;
    pathnode->subpath = subpath;
    pathnode->limitOffset = limitOffset;
    pathnode->limitCount = limitCount;
    pathnode->limitOption = limitOption;
 
    /*
     * Adjust the output rows count and costs according to the offset/limit.
     */
    adjust_limit_rows_costs(&pathnode->path.rows,
                            &pathnode->path.startup_cost,
                            &pathnode->path.total_cost,
                            offset_est, count_est);
 
    return pathnode;
}

References adjust_limit_rows_costs(), RelOptInfo::consider_parallel, Path::disabled_nodes, LimitPath::limitCount, LimitPath::limitOffset, LimitPath::limitOption, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, LimitPath::path, Path::pathkeys, Path::pathtype, Path::rows, Path::startup_cost, subpath(), LimitPath::subpath, and Path::total_cost.

Referenced by create_final_distinct_paths(), create_partial_distinct_paths(), and grouping_planner().

create_lockrows_path()

LockRowsPath * create_lockrows_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	rowMarks,
		int	epqParam
	)

Definition at line 3816 of file pathnode.c.

{
    LockRowsPath *pathnode = makeNode(LockRowsPath);
 
    pathnode->path.pathtype = T_LockRows;
    pathnode->path.parent = rel;
    /* LockRows doesn't project, so use source path's pathtarget */
    pathnode->path.pathtarget = subpath->pathtarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = false;
    pathnode->path.parallel_workers = 0;
    pathnode->path.rows = subpath->rows;
 
    /*
     * The result cannot be assumed sorted, since locking might cause the sort
     * key columns to be replaced with new values.
     */
    pathnode->path.pathkeys = NIL;
 
    pathnode->subpath = subpath;
    pathnode->rowMarks = rowMarks;
    pathnode->epqParam = epqParam;
 
    /*
     * We should charge something extra for the costs of row locking and
     * possible refetches, but it's hard to say how much.  For now, use
     * cpu_tuple_cost per row.
     */
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
    pathnode->path.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost +
        cpu_tuple_cost * subpath->rows;
 
    return pathnode;
}

References cpu_tuple_cost, Path::disabled_nodes, LockRowsPath::epqParam, makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, LockRowsPath::path, Path::pathkeys, Path::pathtype, LockRowsPath::rowMarks, Path::rows, Path::startup_cost, subpath(), LockRowsPath::subpath, and Path::total_cost.

Referenced by grouping_planner().

create_material_path()

MaterialPath * create_material_path	(	RelOptInfo *	rel,
		Path *	subpath
	)

Definition at line 1634 of file pathnode.c.

{
    MaterialPath *pathnode = makeNode(MaterialPath);
 
    Assert(subpath->parent == rel);
 
    pathnode->path.pathtype = T_Material;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = subpath->param_info;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
 
    cost_material(&pathnode->path,
                  subpath->disabled_nodes,
                  subpath->startup_cost,
                  subpath->total_cost,
                  subpath->rows,
                  subpath->pathtarget->width);
 
    return pathnode;
}

References Assert(), RelOptInfo::consider_parallel, cost_material(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, MaterialPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, subpath(), and MaterialPath::subpath.

Referenced by consider_parallel_nestloop(), match_unsorted_outer(), reparameterize_path(), and set_tablesample_rel_pathlist().

create_memoize_path()

MemoizePath * create_memoize_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	param_exprs,
		List *	hash_operators,
		bool	singlerow,
		bool	binary_mode,
		double	calls
	)

Definition at line 1667 of file pathnode.c.

{
    MemoizePath *pathnode = makeNode(MemoizePath);
 
    Assert(subpath->parent == rel);
 
    pathnode->path.pathtype = T_Memoize;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = subpath->param_info;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
    pathnode->hash_operators = hash_operators;
    pathnode->param_exprs = param_exprs;
    pathnode->singlerow = singlerow;
    pathnode->binary_mode = binary_mode;
    pathnode->calls = clamp_row_est(calls);
 
    /*
     * For now we set est_entries to 0.  cost_memoize_rescan() does all the
     * hard work to determine how many cache entries there are likely to be,
     * so it seems best to leave it up to that function to fill this field in.
     * If left at 0, the executor will make a guess at a good value.
     */
    pathnode->est_entries = 0;
 
    /* we should not generate this path type when enable_memoize=false */
    Assert(enable_memoize);
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
 
    /*
     * Add a small additional charge for caching the first entry.  All the
     * harder calculations for rescans are performed in cost_memoize_rescan().
     */
    pathnode->path.startup_cost = subpath->startup_cost + cpu_tuple_cost;
    pathnode->path.total_cost = subpath->total_cost + cpu_tuple_cost;
    pathnode->path.rows = subpath->rows;
 
    return pathnode;
}

References Assert(), MemoizePath::binary_mode, MemoizePath::calls, clamp_row_est(), RelOptInfo::consider_parallel, cpu_tuple_cost, Path::disabled_nodes, enable_memoize, MemoizePath::est_entries, MemoizePath::hash_operators, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, MemoizePath::param_exprs, MemoizePath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, Path::rows, MemoizePath::singlerow, Path::startup_cost, subpath(), MemoizePath::subpath, and Path::total_cost.

Referenced by get_memoize_path(), and reparameterize_path().

create_merge_append_path()

MergeAppendPath * create_merge_append_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	subpaths,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 1471 of file pathnode.c.

{
    MergeAppendPath *pathnode = makeNode(MergeAppendPath);
    int         input_disabled_nodes;
    Cost        input_startup_cost;
    Cost        input_total_cost;
    ListCell   *l;
 
    /*
     * We don't currently support parameterized MergeAppend paths, as
     * explained in the comments for generate_orderedappend_paths.
     */
    Assert(bms_is_empty(rel->lateral_relids) && bms_is_empty(required_outer));
 
    pathnode->path.pathtype = T_MergeAppend;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = pathkeys;
    pathnode->subpaths = subpaths;
 
    /*
     * Apply query-wide LIMIT if known and path is for sole base relation.
     * (Handling this at this low level is a bit klugy.)
     */
    if (bms_equal(rel->relids, root->all_query_rels))
        pathnode->limit_tuples = root->limit_tuples;
    else
        pathnode->limit_tuples = -1.0;
 
    /*
     * Add up the sizes and costs of the input paths.
     */
    pathnode->path.rows = 0;
    input_disabled_nodes = 0;
    input_startup_cost = 0;
    input_total_cost = 0;
    foreach(l, subpaths)
    {
        Path       *subpath = (Path *) lfirst(l);
 
        /* All child paths should be unparameterized */
        Assert(bms_is_empty(PATH_REQ_OUTER(subpath)));
 
        pathnode->path.rows += subpath->rows;
        pathnode->path.parallel_safe = pathnode->path.parallel_safe &&
            subpath->parallel_safe;
 
        if (pathkeys_contained_in(pathkeys, subpath->pathkeys))
        {
            /* Subpath is adequately ordered, we won't need to sort it */
            input_disabled_nodes += subpath->disabled_nodes;
            input_startup_cost += subpath->startup_cost;
            input_total_cost += subpath->total_cost;
        }
        else
        {
            /* We'll need to insert a Sort node, so include cost for that */
            Path        sort_path;  /* dummy for result of cost_sort */
 
            cost_sort(&sort_path,
                      root,
                      pathkeys,
                      subpath->disabled_nodes,
                      subpath->total_cost,
                      subpath->rows,
                      subpath->pathtarget->width,
                      0.0,
                      work_mem,
                      pathnode->limit_tuples);
            input_disabled_nodes += sort_path.disabled_nodes;
            input_startup_cost += sort_path.startup_cost;
            input_total_cost += sort_path.total_cost;
        }
    }
 
    /*
     * Now we can compute total costs of the MergeAppend.  If there's exactly
     * one child path and its parallel awareness matches that of the
     * MergeAppend, then the MergeAppend is a no-op and will be discarded
     * later (in setrefs.c); otherwise we do the normal cost calculation.
     */
    if (list_length(subpaths) == 1 &&
        ((Path *) linitial(subpaths))->parallel_aware ==
        pathnode->path.parallel_aware)
    {
        pathnode->path.disabled_nodes = input_disabled_nodes;
        pathnode->path.startup_cost = input_startup_cost;
        pathnode->path.total_cost = input_total_cost;
    }
    else
        cost_merge_append(&pathnode->path, root,
                          pathkeys, list_length(subpaths),
                          input_disabled_nodes,
                          input_startup_cost, input_total_cost,
                          pathnode->path.rows);
 
    return pathnode;
}

References Assert(), bms_equal(), bms_is_empty, RelOptInfo::consider_parallel, cost_merge_append(), cost_sort(), Path::disabled_nodes, RelOptInfo::lateral_relids, lfirst, MergeAppendPath::limit_tuples, linitial, list_length(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, MergeAppendPath::path, PATH_REQ_OUTER, Path::pathkeys, pathkeys_contained_in(), Path::pathtype, RelOptInfo::relids, RelOptInfo::reltarget, root, Path::rows, Path::startup_cost, subpath(), MergeAppendPath::subpaths, Path::total_cost, and work_mem.

Referenced by generate_orderedappend_paths(), and generate_union_paths().

create_mergejoin_path()

MergePath * create_mergejoin_path	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		JoinType	jointype,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra,
		Path *	outer_path,
		Path *	inner_path,
		List *	restrict_clauses,
		List *	pathkeys,
		Relids	required_outer,
		List *	mergeclauses,
		List *	outersortkeys,
		List *	innersortkeys,
		int	outer_presorted_keys
	)

Definition at line 2632 of file pathnode.c.

{
    MergePath  *pathnode = makeNode(MergePath);
 
    pathnode->jpath.path.pathtype = T_MergeJoin;
    pathnode->jpath.path.parent = joinrel;
    pathnode->jpath.path.pathtarget = joinrel->reltarget;
    pathnode->jpath.path.param_info =
        get_joinrel_parampathinfo(root,
                                  joinrel,
                                  outer_path,
                                  inner_path,
                                  extra->sjinfo,
                                  required_outer,
                                  &restrict_clauses);
    pathnode->jpath.path.parallel_aware = false;
    pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
        outer_path->parallel_safe && inner_path->parallel_safe;
    /* This is a foolish way to estimate parallel_workers, but for now... */
    pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
    pathnode->jpath.path.pathkeys = pathkeys;
    pathnode->jpath.jointype = jointype;
    pathnode->jpath.inner_unique = extra->inner_unique;
    pathnode->jpath.outerjoinpath = outer_path;
    pathnode->jpath.innerjoinpath = inner_path;
    pathnode->jpath.joinrestrictinfo = restrict_clauses;
    pathnode->path_mergeclauses = mergeclauses;
    pathnode->outersortkeys = outersortkeys;
    pathnode->innersortkeys = innersortkeys;
    pathnode->outer_presorted_keys = outer_presorted_keys;
    /* pathnode->skip_mark_restore will be set by final_cost_mergejoin */
    /* pathnode->materialize_inner will be set by final_cost_mergejoin */
 
    final_cost_mergejoin(root, pathnode, workspace, extra);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, final_cost_mergejoin(), get_joinrel_parampathinfo(), JoinPath::inner_unique, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, MergePath::innersortkeys, JoinPath::joinrestrictinfo, JoinPath::jointype, MergePath::jpath, makeNode, MergePath::outer_presorted_keys, JoinPath::outerjoinpath, MergePath::outersortkeys, Path::parallel_safe, Path::parallel_workers, MergePath::path_mergeclauses, RelOptInfo::reltarget, root, and JoinPathExtraData::sjinfo.

Referenced by try_mergejoin_path(), and try_partial_mergejoin_path().

create_minmaxagg_path()

MinMaxAggPath * create_minmaxagg_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		PathTarget *	target,
		List *	mmaggregates,
		List *	quals
	)

Definition at line 3489 of file pathnode.c.

{
    MinMaxAggPath *pathnode = makeNode(MinMaxAggPath);
    Cost        initplan_cost;
    int         initplan_disabled_nodes = 0;
    ListCell   *lc;
 
    /* The topmost generated Plan node will be a Result */
    pathnode->path.pathtype = T_Result;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = true;    /* might change below */
    pathnode->path.parallel_workers = 0;
    /* Result is one unordered row */
    pathnode->path.rows = 1;
    pathnode->path.pathkeys = NIL;
 
    pathnode->mmaggregates = mmaggregates;
    pathnode->quals = quals;
 
    /* Calculate cost of all the initplans, and check parallel safety */
    initplan_cost = 0;
    foreach(lc, mmaggregates)
    {
        MinMaxAggInfo *mminfo = (MinMaxAggInfo *) lfirst(lc);
 
        initplan_disabled_nodes += mminfo->path->disabled_nodes;
        initplan_cost += mminfo->pathcost;
        if (!mminfo->path->parallel_safe)
            pathnode->path.parallel_safe = false;
    }
 
    /* add tlist eval cost for each output row, plus cpu_tuple_cost */
    pathnode->path.disabled_nodes = initplan_disabled_nodes;
    pathnode->path.startup_cost = initplan_cost + target->cost.startup;
    pathnode->path.total_cost = initplan_cost + target->cost.startup +
        target->cost.per_tuple + cpu_tuple_cost;
 
    /*
     * Add cost of qual, if any --- but we ignore its selectivity, since our
     * rowcount estimate should be 1 no matter what the qual is.
     */
    if (quals)
    {
        QualCost    qual_cost;
 
        cost_qual_eval(&qual_cost, quals, root);
        pathnode->path.startup_cost += qual_cost.startup;
        pathnode->path.total_cost += qual_cost.startup + qual_cost.per_tuple;
    }
 
    /*
     * If the initplans were all parallel-safe, also check safety of the
     * target and quals.  (The Result node itself isn't parallelizable, but if
     * we are in a subquery then it can be useful for the outer query to know
     * that this one is parallel-safe.)
     */
    if (pathnode->path.parallel_safe)
        pathnode->path.parallel_safe =
            is_parallel_safe(root, (Node *) target->exprs) &&
            is_parallel_safe(root, (Node *) quals);
 
    return pathnode;
}

References PathTarget::cost, cost_qual_eval(), cpu_tuple_cost, Path::disabled_nodes, PathTarget::exprs, is_parallel_safe(), lfirst, makeNode, MinMaxAggPath::mmaggregates, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, MinMaxAggPath::path, MinMaxAggInfo::path, MinMaxAggInfo::pathcost, Path::pathkeys, Path::pathtype, QualCost::per_tuple, MinMaxAggPath::quals, root, Path::rows, QualCost::startup, Path::startup_cost, and Path::total_cost.

Referenced by preprocess_minmax_aggregates().

create_modifytable_path()

ModifyTablePath * create_modifytable_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		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
	)

Definition at line 3880 of file pathnode.c.

{
    ModifyTablePath *pathnode = makeNode(ModifyTablePath);
 
    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));
 
    pathnode->path.pathtype = T_ModifyTable;
    pathnode->path.parent = rel;
    /* pathtarget is not interesting, just make it minimally valid */
    pathnode->path.pathtarget = rel->reltarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = false;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = NIL;
 
    /*
     * Compute cost & rowcount as subpath cost & rowcount (if RETURNING)
     *
     * Currently, we don't charge anything extra for the actual table
     * modification work, nor for the WITH CHECK OPTIONS or RETURNING
     * expressions if any.  It would only be window dressing, since
     * ModifyTable is always a top-level node and there is no way for the
     * costs to change any higher-level planning choices.  But we might want
     * to make it look better sometime.
     */
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
    pathnode->path.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost;
    if (returningLists != NIL)
    {
        pathnode->path.rows = subpath->rows;
 
        /*
         * Set width to match the subpath output.  XXX this is totally wrong:
         * we should return an average of the RETURNING tlist widths.  But
         * it's what happened historically, and improving it is a task for
         * another day.  (Again, it's mostly window dressing.)
         */
        pathnode->path.pathtarget->width = subpath->pathtarget->width;
    }
    else
    {
        pathnode->path.rows = 0;
        pathnode->path.pathtarget->width = 0;
    }
 
    pathnode->subpath = subpath;
    pathnode->operation = operation;
    pathnode->canSetTag = canSetTag;
    pathnode->nominalRelation = nominalRelation;
    pathnode->rootRelation = rootRelation;
    pathnode->partColsUpdated = partColsUpdated;
    pathnode->resultRelations = resultRelations;
    pathnode->updateColnosLists = updateColnosLists;
    pathnode->withCheckOptionLists = withCheckOptionLists;
    pathnode->returningLists = returningLists;
    pathnode->rowMarks = rowMarks;
    pathnode->onconflict = onconflict;
    pathnode->epqParam = epqParam;
    pathnode->mergeActionLists = mergeActionLists;
    pathnode->mergeJoinConditions = mergeJoinConditions;
 
    return pathnode;
}

References Assert(), ModifyTablePath::canSetTag, CMD_MERGE, CMD_UPDATE, Path::disabled_nodes, ModifyTablePath::epqParam, list_length(), makeNode, ModifyTablePath::mergeActionLists, ModifyTablePath::mergeJoinConditions, NIL, ModifyTablePath::nominalRelation, ModifyTablePath::onconflict, ModifyTablePath::operation, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ModifyTablePath::partColsUpdated, ModifyTablePath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, ModifyTablePath::resultRelations, ModifyTablePath::returningLists, ModifyTablePath::rootRelation, ModifyTablePath::rowMarks, Path::rows, Path::startup_cost, subpath(), ModifyTablePath::subpath, Path::total_cost, ModifyTablePath::updateColnosLists, and ModifyTablePath::withCheckOptionLists.

Referenced by grouping_planner().

create_namedtuplestorescan_path()

Path * create_namedtuplestorescan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 2222 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_NamedTuplestoreScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* result is always unordered */
 
    cost_namedtuplestorescan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_namedtuplestorescan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_namedtuplestore_pathlist().

create_nestloop_path()

NestPath * create_nestloop_path	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		JoinType	jointype,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra,
		Path *	outer_path,
		Path *	inner_path,
		List *	restrict_clauses,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 2535 of file pathnode.c.

{
    NestPath   *pathnode = makeNode(NestPath);
    Relids      inner_req_outer = PATH_REQ_OUTER(inner_path);
    Relids      outerrelids;
 
    /*
     * Paths are parameterized by top-level parents, so run parameterization
     * tests on the parent relids.
     */
    if (outer_path->parent->top_parent_relids)
        outerrelids = outer_path->parent->top_parent_relids;
    else
        outerrelids = outer_path->parent->relids;
 
    /*
     * If the inner path is parameterized by the outer, we must drop any
     * restrict_clauses that are due to be moved into the inner path.  We have
     * to do this now, rather than postpone the work till createplan time,
     * because the restrict_clauses list can affect the size and cost
     * estimates for this path.  We detect such clauses by checking for serial
     * number match to clauses already enforced in the inner path.
     */
    if (bms_overlap(inner_req_outer, outerrelids))
    {
        Bitmapset  *enforced_serials = get_param_path_clause_serials(inner_path);
        List       *jclauses = NIL;
        ListCell   *lc;
 
        foreach(lc, restrict_clauses)
        {
            RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
            if (!bms_is_member(rinfo->rinfo_serial, enforced_serials))
                jclauses = lappend(jclauses, rinfo);
        }
        restrict_clauses = jclauses;
    }
 
    pathnode->jpath.path.pathtype = T_NestLoop;
    pathnode->jpath.path.parent = joinrel;
    pathnode->jpath.path.pathtarget = joinrel->reltarget;
    pathnode->jpath.path.param_info =
        get_joinrel_parampathinfo(root,
                                  joinrel,
                                  outer_path,
                                  inner_path,
                                  extra->sjinfo,
                                  required_outer,
                                  &restrict_clauses);
    pathnode->jpath.path.parallel_aware = false;
    pathnode->jpath.path.parallel_safe = joinrel->consider_parallel &&
        outer_path->parallel_safe && inner_path->parallel_safe;
    /* This is a foolish way to estimate parallel_workers, but for now... */
    pathnode->jpath.path.parallel_workers = outer_path->parallel_workers;
    pathnode->jpath.path.pathkeys = pathkeys;
    pathnode->jpath.jointype = jointype;
    pathnode->jpath.inner_unique = extra->inner_unique;
    pathnode->jpath.outerjoinpath = outer_path;
    pathnode->jpath.innerjoinpath = inner_path;
    pathnode->jpath.joinrestrictinfo = restrict_clauses;
 
    final_cost_nestloop(root, pathnode, workspace, extra);
 
    return pathnode;
}

References bms_is_member(), bms_overlap(), RelOptInfo::consider_parallel, final_cost_nestloop(), get_joinrel_parampathinfo(), get_param_path_clause_serials(), JoinPath::inner_unique, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, JoinPath::joinrestrictinfo, JoinPath::jointype, NestPath::jpath, lappend(), lfirst, makeNode, NIL, JoinPath::outerjoinpath, Path::parallel_safe, Path::parallel_workers, PATH_REQ_OUTER, RelOptInfo::reltarget, RestrictInfo::rinfo_serial, root, and JoinPathExtraData::sjinfo.

Referenced by try_nestloop_path(), and try_partial_nestloop_path().

create_projection_path()

ProjectionPath * create_projection_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target
	)

Definition at line 2766 of file pathnode.c.

{
    ProjectionPath *pathnode = makeNode(ProjectionPath);
    PathTarget *oldtarget;
 
    /*
     * We mustn't put a ProjectionPath directly above another; it's useless
     * and will confuse create_projection_plan.  Rather than making sure all
     * callers handle that, let's implement it here, by stripping off any
     * ProjectionPath in what we're given.  Given this rule, there won't be
     * more than one.
     */
    if (IsA(subpath, ProjectionPath))
    {
        ProjectionPath *subpp = (ProjectionPath *) subpath;
 
        Assert(subpp->path.parent == rel);
        subpath = subpp->subpath;
        Assert(!IsA(subpath, ProjectionPath));
    }
 
    pathnode->path.pathtype = T_Result;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe &&
        is_parallel_safe(root, (Node *) target->exprs);
    pathnode->path.parallel_workers = subpath->parallel_workers;
    /* Projection does not change the sort order */
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
 
    /*
     * We might not need a separate Result node.  If the input plan node type
     * can project, we can just tell it to project something else.  Or, if it
     * can't project but the desired target has the same expression list as
     * what the input will produce anyway, we can still give it the desired
     * tlist (possibly changing its ressortgroupref labels, but nothing else).
     * Note: in the latter case, create_projection_plan has to recheck our
     * conclusion; see comments therein.
     */
    oldtarget = subpath->pathtarget;
    if (is_projection_capable_path(subpath) ||
        equal(oldtarget->exprs, target->exprs))
    {
        /* No separate Result node needed */
        pathnode->dummypp = true;
 
        /*
         * Set cost of plan as subpath's cost, adjusted for tlist replacement.
         */
        pathnode->path.rows = subpath->rows;
        pathnode->path.disabled_nodes = subpath->disabled_nodes;
        pathnode->path.startup_cost = subpath->startup_cost +
            (target->cost.startup - oldtarget->cost.startup);
        pathnode->path.total_cost = subpath->total_cost +
            (target->cost.startup - oldtarget->cost.startup) +
            (target->cost.per_tuple - oldtarget->cost.per_tuple) * subpath->rows;
    }
    else
    {
        /* We really do need the Result node */
        pathnode->dummypp = false;
 
        /*
         * The Result node's cost is cpu_tuple_cost per row, plus the cost of
         * evaluating the tlist.  There is no qual to worry about.
         */
        pathnode->path.rows = subpath->rows;
        pathnode->path.disabled_nodes = subpath->disabled_nodes;
        pathnode->path.startup_cost = subpath->startup_cost +
            target->cost.startup;
        pathnode->path.total_cost = subpath->total_cost +
            target->cost.startup +
            (cpu_tuple_cost + target->cost.per_tuple) * subpath->rows;
    }
 
    return pathnode;
}

References Assert(), RelOptInfo::consider_parallel, PathTarget::cost, cpu_tuple_cost, Path::disabled_nodes, ProjectionPath::dummypp, equal(), PathTarget::exprs, is_parallel_safe(), is_projection_capable_path(), IsA, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ProjectionPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, root, Path::rows, QualCost::startup, Path::startup_cost, subpath(), ProjectionPath::subpath, and Path::total_cost.

Referenced by add_paths_with_pathkeys_for_rel(), adjust_paths_for_srfs(), apply_projection_to_path(), apply_scanjoin_target_to_paths(), and recurse_set_operations().

create_recursiveunion_path()

RecursiveUnionPath * create_recursiveunion_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	leftpath,
		Path *	rightpath,
		PathTarget *	target,
		List *	distinctList,
		int	wtParam,
		double	numGroups
	)

Definition at line 3771 of file pathnode.c.

{
    RecursiveUnionPath *pathnode = makeNode(RecursiveUnionPath);
 
    pathnode->path.pathtype = T_RecursiveUnion;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        leftpath->parallel_safe && rightpath->parallel_safe;
    /* Foolish, but we'll do it like joins for now: */
    pathnode->path.parallel_workers = leftpath->parallel_workers;
    /* RecursiveUnion result is always unsorted */
    pathnode->path.pathkeys = NIL;
 
    pathnode->leftpath = leftpath;
    pathnode->rightpath = rightpath;
    pathnode->distinctList = distinctList;
    pathnode->wtParam = wtParam;
    pathnode->numGroups = numGroups;
 
    cost_recursive_union(&pathnode->path, leftpath, rightpath);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_recursive_union(), RecursiveUnionPath::distinctList, RecursiveUnionPath::leftpath, makeNode, NIL, RecursiveUnionPath::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, RecursiveUnionPath::path, Path::pathkeys, Path::pathtype, RecursiveUnionPath::rightpath, and RecursiveUnionPath::wtParam.

Referenced by generate_recursion_path().

create_resultscan_path()

Path * create_resultscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 2248 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_Result;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* result is always unordered */
 
    cost_resultscan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_resultscan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by reparameterize_path(), and set_result_pathlist().

create_samplescan_path()

Path * create_samplescan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 1008 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_SampleScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* samplescan has unordered result */
 
    cost_samplescan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_samplescan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by reparameterize_path(), and set_tablesample_rel_pathlist().

create_seqscan_path()

Path * create_seqscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer,
		int	parallel_workers
	)

Definition at line 983 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_SeqScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = (parallel_workers > 0);
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = parallel_workers;
    pathnode->pathkeys = NIL;   /* seqscan has unordered result */
 
    cost_seqscan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_seqscan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by create_plain_partial_paths(), plan_cluster_use_sort(), reparameterize_path(), and set_plain_rel_pathlist().

create_set_projection_path()

ProjectSetPath * create_set_projection_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target
	)

Definition at line 2965 of file pathnode.c.

{
    ProjectSetPath *pathnode = makeNode(ProjectSetPath);
    double      tlist_rows;
    ListCell   *lc;
 
    pathnode->path.pathtype = T_ProjectSet;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe &&
        is_parallel_safe(root, (Node *) target->exprs);
    pathnode->path.parallel_workers = subpath->parallel_workers;
    /* Projection does not change the sort order XXX? */
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
 
    /*
     * Estimate number of rows produced by SRFs for each row of input; if
     * there's more than one in this node, use the maximum.
     */
    tlist_rows = 1;
    foreach(lc, target->exprs)
    {
        Node       *node = (Node *) lfirst(lc);
        double      itemrows;
 
        itemrows = expression_returns_set_rows(root, node);
        if (tlist_rows < itemrows)
            tlist_rows = itemrows;
    }
 
    /*
     * In addition to the cost of evaluating the tlist, charge cpu_tuple_cost
     * per input row, and half of cpu_tuple_cost for each added output row.
     * This is slightly bizarre maybe, but it's what 9.6 did; we may revisit
     * this estimate later.
     */
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
    pathnode->path.rows = subpath->rows * tlist_rows;
    pathnode->path.startup_cost = subpath->startup_cost +
        target->cost.startup;
    pathnode->path.total_cost = subpath->total_cost +
        target->cost.startup +
        (cpu_tuple_cost + target->cost.per_tuple) * subpath->rows +
        (pathnode->path.rows - subpath->rows) * cpu_tuple_cost / 2;
 
    return pathnode;
}

References RelOptInfo::consider_parallel, PathTarget::cost, cpu_tuple_cost, Path::disabled_nodes, expression_returns_set_rows(), PathTarget::exprs, is_parallel_safe(), lfirst, makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, ProjectSetPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, root, Path::rows, QualCost::startup, Path::startup_cost, subpath(), ProjectSetPath::subpath, and Path::total_cost.

Referenced by adjust_paths_for_srfs().

create_setop_path()

SetOpPath * create_setop_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	leftpath,
		Path *	rightpath,
		SetOpCmd	cmd,
		SetOpStrategy	strategy,
		List *	groupList,
		double	numGroups,
		double	outputRows
	)

Definition at line 3653 of file pathnode.c.

{
    SetOpPath  *pathnode = makeNode(SetOpPath);
 
    pathnode->path.pathtype = T_SetOp;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        leftpath->parallel_safe && rightpath->parallel_safe;
    pathnode->path.parallel_workers =
        leftpath->parallel_workers + rightpath->parallel_workers;
    /* SetOp preserves the input sort order if in sort mode */
    pathnode->path.pathkeys =
        (strategy == SETOP_SORTED) ? leftpath->pathkeys : NIL;
 
    pathnode->leftpath = leftpath;
    pathnode->rightpath = rightpath;
    pathnode->cmd = cmd;
    pathnode->strategy = strategy;
    pathnode->groupList = groupList;
    pathnode->numGroups = numGroups;
 
    /*
     * Compute cost estimates.  As things stand, we end up with the same total
     * cost in this node for sort and hash methods, but different startup
     * costs.  This could be refined perhaps, but it'll do for now.
     */
    pathnode->path.disabled_nodes =
        leftpath->disabled_nodes + rightpath->disabled_nodes;
    if (strategy == SETOP_SORTED)
    {
        /*
         * In sorted mode, we can emit output incrementally.  Charge one
         * cpu_operator_cost per comparison per input tuple.  Like cost_group,
         * we assume all columns get compared at most of the tuples.
         */
        pathnode->path.startup_cost =
            leftpath->startup_cost + rightpath->startup_cost;
        pathnode->path.total_cost =
            leftpath->total_cost + rightpath->total_cost +
            cpu_operator_cost * (leftpath->rows + rightpath->rows) * list_length(groupList);
 
        /*
         * Also charge a small amount per extracted tuple.  Like cost_sort,
         * charge only operator cost not cpu_tuple_cost, since SetOp does no
         * qual-checking or projection.
         */
        pathnode->path.total_cost += cpu_operator_cost * outputRows;
    }
    else
    {
        Size        hashentrysize;
 
        /*
         * In hashed mode, we must read all the input before we can emit
         * anything.  Also charge comparison costs to represent the cost of
         * hash table lookups.
         */
        pathnode->path.startup_cost =
            leftpath->total_cost + rightpath->total_cost +
            cpu_operator_cost * (leftpath->rows + rightpath->rows) * list_length(groupList);
        pathnode->path.total_cost = pathnode->path.startup_cost;
 
        /*
         * Also charge a small amount per extracted tuple.  Like cost_sort,
         * charge only operator cost not cpu_tuple_cost, since SetOp does no
         * qual-checking or projection.
         */
        pathnode->path.total_cost += cpu_operator_cost * outputRows;
 
        /*
         * Mark the path as disabled if enable_hashagg is off.  While this
         * isn't exactly a HashAgg node, it seems close enough to justify
         * letting that switch control it.
         */
        if (!enable_hashagg)
            pathnode->path.disabled_nodes++;
 
        /*
         * Also disable if it doesn't look like the hashtable will fit into
         * hash_mem.
         */
        hashentrysize = MAXALIGN(leftpath->pathtarget->width) +
            MAXALIGN(SizeofMinimalTupleHeader);
        if (hashentrysize * numGroups > get_hash_memory_limit())
            pathnode->path.disabled_nodes++;
    }
    pathnode->path.rows = outputRows;
 
    return pathnode;
}

References SetOpPath::cmd, RelOptInfo::consider_parallel, cpu_operator_cost, Path::disabled_nodes, enable_hashagg, get_hash_memory_limit(), SetOpPath::groupList, if(), SetOpPath::leftpath, list_length(), makeNode, MAXALIGN, NIL, SetOpPath::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, SetOpPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, SetOpPath::rightpath, Path::rows, SETOP_SORTED, SizeofMinimalTupleHeader, Path::startup_cost, SetOpPath::strategy, and Path::total_cost.

Referenced by generate_nonunion_paths().

create_sort_path()

SortPath * create_sort_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		List *	pathkeys,
		double	limit_tuples
	)

Definition at line 3085 of file pathnode.c.

{
    SortPath   *pathnode = makeNode(SortPath);
 
    pathnode->path.pathtype = T_Sort;
    pathnode->path.parent = rel;
    /* Sort doesn't project, so use source path's pathtarget */
    pathnode->path.pathtarget = subpath->pathtarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = pathkeys;
 
    pathnode->subpath = subpath;
 
    cost_sort(&pathnode->path, root, pathkeys,
              subpath->disabled_nodes,
              subpath->total_cost,
              subpath->rows,
              subpath->pathtarget->width,
              0.0,              /* XXX comparison_cost shouldn't be 0? */
              work_mem, limit_tuples);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_sort(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, SortPath::path, Path::pathkeys, Path::pathtype, root, subpath(), SortPath::subpath, and work_mem.

Referenced by add_paths_with_pathkeys_for_rel(), build_setop_child_paths(), create_one_window_path(), create_ordered_paths(), gather_grouping_paths(), generate_nonunion_paths(), generate_union_paths(), generate_useful_gather_paths(), and make_ordered_path().

create_subqueryscan_path()

SubqueryScanPath * create_subqueryscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		bool	trivial_pathtarget,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 2088 of file pathnode.c.

{
    SubqueryScanPath *pathnode = makeNode(SubqueryScanPath);
 
    pathnode->path.pathtype = T_SubqueryScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    pathnode->path.pathkeys = pathkeys;
    pathnode->subpath = subpath;
 
    cost_subqueryscan(pathnode, root, rel, pathnode->path.param_info,
                      trivial_pathtarget);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_subqueryscan(), get_baserel_parampathinfo(), makeNode, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, SubqueryScanPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, root, subpath(), and SubqueryScanPath::subpath.

Referenced by build_setop_child_paths(), reparameterize_path(), and set_subquery_pathlist().

create_tablefuncscan_path()

Path * create_tablefuncscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 2144 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_TableFuncScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* result is always unordered */
 
    cost_tablefuncscan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_tablefuncscan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_tablefunc_pathlist().

create_tidrangescan_path()

TidRangePath * create_tidrangescan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	tidrangequals,
		Relids	required_outer
	)

Definition at line 1264 of file pathnode.c.

{
    TidRangePath *pathnode = makeNode(TidRangePath);
 
    pathnode->path.pathtype = T_TidRangeScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = NIL;  /* always unordered */
 
    pathnode->tidrangequals = tidrangequals;
 
    cost_tidrangescan(&pathnode->path, root, rel, tidrangequals,
                      pathnode->path.param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_tidrangescan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, TidRangePath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, root, and TidRangePath::tidrangequals.

Referenced by create_tidscan_paths().

create_tidscan_path()

TidPath * create_tidscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	tidquals,
		Relids	required_outer
	)

Definition at line 1235 of file pathnode.c.

{
    TidPath    *pathnode = makeNode(TidPath);
 
    pathnode->path.pathtype = T_TidScan;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_baserel_parampathinfo(root, rel,
                                                          required_outer);
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel;
    pathnode->path.parallel_workers = 0;
    pathnode->path.pathkeys = NIL;  /* always unordered */
 
    pathnode->tidquals = tidquals;
 
    cost_tidscan(&pathnode->path, root, rel, tidquals,
                 pathnode->path.param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_tidscan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, TidPath::path, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, root, and TidPath::tidquals.

Referenced by BuildParameterizedTidPaths(), and create_tidscan_paths().

create_unique_path()

UniquePath * create_unique_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		SpecialJoinInfo *	sjinfo
	)

Definition at line 1727 of file pathnode.c.

{
    UniquePath *pathnode;
    Path        sort_path;      /* dummy for result of cost_sort */
    Path        agg_path;       /* dummy for result of cost_agg */
    MemoryContext oldcontext;
    int         numCols;
 
    /* Caller made a mistake if subpath isn't cheapest_total ... */
    Assert(subpath == rel->cheapest_total_path);
    Assert(subpath->parent == rel);
    /* ... or if SpecialJoinInfo is the wrong one */
    Assert(sjinfo->jointype == JOIN_SEMI);
    Assert(bms_equal(rel->relids, sjinfo->syn_righthand));
 
    /* If result already cached, return it */
    if (rel->cheapest_unique_path)
        return (UniquePath *) rel->cheapest_unique_path;
 
    /* If it's not possible to unique-ify, return NULL */
    if (!(sjinfo->semi_can_btree || sjinfo->semi_can_hash))
        return NULL;
 
    /*
     * When called during GEQO join planning, we are in a short-lived memory
     * context.  We must make sure that the path and any subsidiary data
     * structures created for a baserel survive the GEQO cycle, else the
     * baserel is trashed for future GEQO cycles.  On the other hand, when we
     * are creating those for a joinrel during GEQO, we don't want them to
     * clutter the main planning context.  Upshot is that the best solution is
     * to explicitly allocate memory in the same context the given RelOptInfo
     * is in.
     */
    oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(rel));
 
    pathnode = makeNode(UniquePath);
 
    pathnode->path.pathtype = T_Unique;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = subpath->param_info;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
 
    /*
     * Assume the output is unsorted, since we don't necessarily have pathkeys
     * to represent it.  (This might get overridden below.)
     */
    pathnode->path.pathkeys = NIL;
 
    pathnode->subpath = subpath;
 
    /*
     * Under GEQO and when planning child joins, the sjinfo might be
     * short-lived, so we'd better make copies of data structures we extract
     * from it.
     */
    pathnode->in_operators = copyObject(sjinfo->semi_operators);
    pathnode->uniq_exprs = copyObject(sjinfo->semi_rhs_exprs);
 
    /*
     * If the input is a relation and it has a unique index that proves the
     * semi_rhs_exprs are unique, then we don't need to do anything.  Note
     * that relation_has_unique_index_for automatically considers restriction
     * clauses for the rel, as well.
     */
    if (rel->rtekind == RTE_RELATION && sjinfo->semi_can_btree &&
        relation_has_unique_index_for(root, rel, NIL,
                                      sjinfo->semi_rhs_exprs,
                                      sjinfo->semi_operators))
    {
        pathnode->umethod = UNIQUE_PATH_NOOP;
        pathnode->path.rows = rel->rows;
        pathnode->path.disabled_nodes = subpath->disabled_nodes;
        pathnode->path.startup_cost = subpath->startup_cost;
        pathnode->path.total_cost = subpath->total_cost;
        pathnode->path.pathkeys = subpath->pathkeys;
 
        rel->cheapest_unique_path = (Path *) pathnode;
 
        MemoryContextSwitchTo(oldcontext);
 
        return pathnode;
    }
 
    /*
     * If the input is a subquery whose output must be unique already, then we
     * don't need to do anything.  The test for uniqueness has to consider
     * exactly which columns we are extracting; for example "SELECT DISTINCT
     * x,y" doesn't guarantee that x alone is distinct. So we cannot check for
     * this optimization unless semi_rhs_exprs consists only of simple Vars
     * referencing subquery outputs.  (Possibly we could do something with
     * expressions in the subquery outputs, too, but for now keep it simple.)
     */
    if (rel->rtekind == RTE_SUBQUERY)
    {
        RangeTblEntry *rte = planner_rt_fetch(rel->relid, root);
 
        if (query_supports_distinctness(rte->subquery))
        {
            List       *sub_tlist_colnos;
 
            sub_tlist_colnos = translate_sub_tlist(sjinfo->semi_rhs_exprs,
                                                   rel->relid);
 
            if (sub_tlist_colnos &&
                query_is_distinct_for(rte->subquery,
                                      sub_tlist_colnos,
                                      sjinfo->semi_operators))
            {
                pathnode->umethod = UNIQUE_PATH_NOOP;
                pathnode->path.rows = rel->rows;
                pathnode->path.disabled_nodes = subpath->disabled_nodes;
                pathnode->path.startup_cost = subpath->startup_cost;
                pathnode->path.total_cost = subpath->total_cost;
                pathnode->path.pathkeys = subpath->pathkeys;
 
                rel->cheapest_unique_path = (Path *) pathnode;
 
                MemoryContextSwitchTo(oldcontext);
 
                return pathnode;
            }
        }
    }
 
    /* Estimate number of output rows */
    pathnode->path.rows = estimate_num_groups(root,
                                              sjinfo->semi_rhs_exprs,
                                              rel->rows,
                                              NULL,
                                              NULL);
    numCols = list_length(sjinfo->semi_rhs_exprs);
 
    if (sjinfo->semi_can_btree)
    {
        /*
         * Estimate cost for sort+unique implementation
         */
        cost_sort(&sort_path, root, NIL,
                  subpath->disabled_nodes,
                  subpath->total_cost,
                  rel->rows,
                  subpath->pathtarget->width,
                  0.0,
                  work_mem,
                  -1.0);
 
        /*
         * Charge one cpu_operator_cost per comparison per input tuple. We
         * assume all columns get compared at most of the tuples. (XXX
         * probably this is an overestimate.)  This should agree with
         * create_upper_unique_path.
         */
        sort_path.total_cost += cpu_operator_cost * rel->rows * numCols;
    }
 
    if (sjinfo->semi_can_hash)
    {
        /*
         * Estimate the overhead per hashtable entry at 64 bytes (same as in
         * planner.c).
         */
        int         hashentrysize = subpath->pathtarget->width + 64;
 
        if (hashentrysize * pathnode->path.rows > get_hash_memory_limit())
        {
            /*
             * We should not try to hash.  Hack the SpecialJoinInfo to
             * remember this, in case we come through here again.
             */
            sjinfo->semi_can_hash = false;
        }
        else
            cost_agg(&agg_path, root,
                     AGG_HASHED, NULL,
                     numCols, pathnode->path.rows,
                     NIL,
                     subpath->disabled_nodes,
                     subpath->startup_cost,
                     subpath->total_cost,
                     rel->rows,
                     subpath->pathtarget->width);
    }
 
    if (sjinfo->semi_can_btree && sjinfo->semi_can_hash)
    {
        if (agg_path.disabled_nodes < sort_path.disabled_nodes ||
            (agg_path.disabled_nodes == sort_path.disabled_nodes &&
             agg_path.total_cost < sort_path.total_cost))
            pathnode->umethod = UNIQUE_PATH_HASH;
        else
            pathnode->umethod = UNIQUE_PATH_SORT;
    }
    else if (sjinfo->semi_can_btree)
        pathnode->umethod = UNIQUE_PATH_SORT;
    else if (sjinfo->semi_can_hash)
        pathnode->umethod = UNIQUE_PATH_HASH;
    else
    {
        /* we can get here only if we abandoned hashing above */
        MemoryContextSwitchTo(oldcontext);
        return NULL;
    }
 
    if (pathnode->umethod == UNIQUE_PATH_HASH)
    {
        pathnode->path.disabled_nodes = agg_path.disabled_nodes;
        pathnode->path.startup_cost = agg_path.startup_cost;
        pathnode->path.total_cost = agg_path.total_cost;
    }
    else
    {
        pathnode->path.disabled_nodes = sort_path.disabled_nodes;
        pathnode->path.startup_cost = sort_path.startup_cost;
        pathnode->path.total_cost = sort_path.total_cost;
    }
 
    rel->cheapest_unique_path = (Path *) pathnode;
 
    MemoryContextSwitchTo(oldcontext);
 
    return pathnode;
}

References AGG_HASHED, Assert(), bms_equal(), RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, RelOptInfo::consider_parallel, copyObject, cost_agg(), cost_sort(), cpu_operator_cost, Path::disabled_nodes, estimate_num_groups(), get_hash_memory_limit(), GetMemoryChunkContext(), UniquePath::in_operators, JOIN_SEMI, SpecialJoinInfo::jointype, list_length(), makeNode, MemoryContextSwitchTo(), NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, UniquePath::path, Path::pathkeys, Path::pathtype, planner_rt_fetch, query_is_distinct_for(), query_supports_distinctness(), relation_has_unique_index_for(), RelOptInfo::relid, RelOptInfo::relids, RelOptInfo::reltarget, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RTE_SUBQUERY, RelOptInfo::rtekind, SpecialJoinInfo::semi_can_btree, SpecialJoinInfo::semi_can_hash, SpecialJoinInfo::semi_operators, SpecialJoinInfo::semi_rhs_exprs, Path::startup_cost, subpath(), UniquePath::subpath, RangeTblEntry::subquery, SpecialJoinInfo::syn_righthand, Path::total_cost, translate_sub_tlist(), UniquePath::umethod, UniquePath::uniq_exprs, UNIQUE_PATH_HASH, UNIQUE_PATH_NOOP, UNIQUE_PATH_SORT, and work_mem.

Referenced by consider_parallel_nestloop(), hash_inner_and_outer(), join_is_legal(), match_unsorted_outer(), populate_joinrel_with_paths(), and sort_inner_and_outer().

create_upper_unique_path()

UpperUniquePath * create_upper_unique_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		int	numCols,
		double	numGroups
	)

Definition at line 3190 of file pathnode.c.

{
    UpperUniquePath *pathnode = makeNode(UpperUniquePath);
 
    pathnode->path.pathtype = T_Unique;
    pathnode->path.parent = rel;
    /* Unique doesn't project, so use source path's pathtarget */
    pathnode->path.pathtarget = subpath->pathtarget;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    /* Unique doesn't change the input ordering */
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
    pathnode->numkeys = numCols;
 
    /*
     * Charge one cpu_operator_cost per comparison per input tuple. We assume
     * all columns get compared at most of the tuples.  (XXX probably this is
     * an overestimate.)
     */
    pathnode->path.disabled_nodes = subpath->disabled_nodes;
    pathnode->path.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost +
        cpu_operator_cost * subpath->rows * numCols;
    pathnode->path.rows = numGroups;
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cpu_operator_cost, Path::disabled_nodes, makeNode, UpperUniquePath::numkeys, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, UpperUniquePath::path, Path::pathkeys, Path::pathtype, Path::rows, Path::startup_cost, subpath(), UpperUniquePath::subpath, and Path::total_cost.

Referenced by create_final_distinct_paths(), create_partial_distinct_paths(), and generate_union_paths().

create_valuesscan_path()

Path * create_valuesscan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 2170 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_ValuesScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* result is always unordered */
 
    cost_valuesscan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_valuesscan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_values_pathlist().

create_windowagg_path()

WindowAggPath * create_windowagg_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	subpath,
		PathTarget *	target,
		List *	windowFuncs,
		List *	runCondition,
		WindowClause *	winclause,
		List *	qual,
		bool	topwindow
	)

Definition at line 3580 of file pathnode.c.

{
    WindowAggPath *pathnode = makeNode(WindowAggPath);
 
    /* qual can only be set for the topwindow */
    Assert(qual == NIL || topwindow);
 
    pathnode->path.pathtype = T_WindowAgg;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = target;
    /* For now, assume we are above any joins, so no parameterization */
    pathnode->path.param_info = NULL;
    pathnode->path.parallel_aware = false;
    pathnode->path.parallel_safe = rel->consider_parallel &&
        subpath->parallel_safe;
    pathnode->path.parallel_workers = subpath->parallel_workers;
    /* WindowAgg preserves the input sort order */
    pathnode->path.pathkeys = subpath->pathkeys;
 
    pathnode->subpath = subpath;
    pathnode->winclause = winclause;
    pathnode->qual = qual;
    pathnode->runCondition = runCondition;
    pathnode->topwindow = topwindow;
 
    /*
     * For costing purposes, assume that there are no redundant partitioning
     * or ordering columns; it's not worth the trouble to deal with that
     * corner case here.  So we just pass the unmodified list lengths to
     * cost_windowagg.
     */
    cost_windowagg(&pathnode->path, root,
                   windowFuncs,
                   winclause,
                   subpath->disabled_nodes,
                   subpath->startup_cost,
                   subpath->total_cost,
                   subpath->rows);
 
    /* add tlist eval cost for each output row */
    pathnode->path.startup_cost += target->cost.startup;
    pathnode->path.total_cost += target->cost.startup +
        target->cost.per_tuple * pathnode->path.rows;
 
    return pathnode;
}

References Assert(), RelOptInfo::consider_parallel, PathTarget::cost, cost_windowagg(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, WindowAggPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, WindowAggPath::qual, root, Path::rows, WindowAggPath::runCondition, QualCost::startup, Path::startup_cost, subpath(), WindowAggPath::subpath, WindowAggPath::topwindow, Path::total_cost, and WindowAggPath::winclause.

Referenced by create_one_window_path().

create_worktablescan_path()

Path * create_worktablescan_path	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 2274 of file pathnode.c.

{
    Path       *pathnode = makeNode(Path);
 
    pathnode->pathtype = T_WorkTableScan;
    pathnode->parent = rel;
    pathnode->pathtarget = rel->reltarget;
    pathnode->param_info = get_baserel_parampathinfo(root, rel,
                                                     required_outer);
    pathnode->parallel_aware = false;
    pathnode->parallel_safe = rel->consider_parallel;
    pathnode->parallel_workers = 0;
    pathnode->pathkeys = NIL;   /* result is always unordered */
 
    /* Cost is the same as for a regular CTE scan */
    cost_ctescan(pathnode, root, rel, pathnode->param_info);
 
    return pathnode;
}

References RelOptInfo::consider_parallel, cost_ctescan(), get_baserel_parampathinfo(), makeNode, NIL, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, Path::pathkeys, Path::pathtype, RelOptInfo::reltarget, and root.

Referenced by set_worktable_pathlist().

expand_planner_arrays()

void expand_planner_arrays	(	PlannerInfo *	root,
		int	add_size
	)

Definition at line 163 of file relnode.c.

{
    int         new_size;
 
    Assert(add_size > 0);
 
    new_size = root->simple_rel_array_size + add_size;
 
    root->simple_rel_array =
        repalloc0_array(root->simple_rel_array, RelOptInfo *, root->simple_rel_array_size, new_size);
 
    root->simple_rte_array =
        repalloc0_array(root->simple_rte_array, RangeTblEntry *, root->simple_rel_array_size, new_size);
 
    if (root->append_rel_array)
        root->append_rel_array =
            repalloc0_array(root->append_rel_array, AppendRelInfo *, root->simple_rel_array_size, new_size);
    else
        root->append_rel_array =
            palloc0_array(AppendRelInfo *, new_size);
 
    root->simple_rel_array_size = new_size;
}

References add_size(), Assert(), palloc0_array, repalloc0_array, and root.

Referenced by expand_inherited_rtentry(), and expand_partitioned_rtentry().

fetch_upper_rel()

RelOptInfo * fetch_upper_rel	(	PlannerInfo *	root,
		UpperRelationKind	kind,
		Relids	relids
	)

Definition at line 1458 of file relnode.c.

{
    RelOptInfo *upperrel;
    ListCell   *lc;
 
    /*
     * For the moment, our indexing data structure is just a List for each
     * relation kind.  If we ever get so many of one kind that this stops
     * working well, we can improve it.  No code outside this function should
     * assume anything about how to find a particular upperrel.
     */
 
    /* If we already made this upperrel for the query, return it */
    foreach(lc, root->upper_rels[kind])
    {
        upperrel = (RelOptInfo *) lfirst(lc);
 
        if (bms_equal(upperrel->relids, relids))
            return upperrel;
    }
 
    upperrel = makeNode(RelOptInfo);
    upperrel->reloptkind = RELOPT_UPPER_REL;
    upperrel->relids = bms_copy(relids);
 
    /* cheap startup cost is interesting iff not all tuples to be retrieved */
    upperrel->consider_startup = (root->tuple_fraction > 0);
    upperrel->consider_param_startup = false;
    upperrel->consider_parallel = false;    /* might get changed later */
    upperrel->reltarget = create_empty_pathtarget();
    upperrel->pathlist = NIL;
    upperrel->cheapest_startup_path = NULL;
    upperrel->cheapest_total_path = NULL;
    upperrel->cheapest_unique_path = NULL;
    upperrel->cheapest_parameterized_paths = NIL;
 
    root->upper_rels[kind] = lappend(root->upper_rels[kind], upperrel);
 
    return upperrel;
}

References bms_copy(), bms_equal(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, RelOptInfo::consider_parallel, RelOptInfo::consider_param_startup, RelOptInfo::consider_startup, create_empty_pathtarget(), lappend(), lfirst, makeNode, NIL, RelOptInfo::pathlist, RelOptInfo::relids, RELOPT_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, and root.

Referenced by add_rtes_to_flat_rtable(), build_setop_child_paths(), create_distinct_paths(), create_ordered_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), create_window_paths(), generate_nonunion_paths(), generate_recursion_path(), generate_union_paths(), grouping_planner(), make_grouping_rel(), make_subplan(), preprocess_minmax_aggregates(), set_subquery_pathlist(), set_subquery_size_estimates(), SS_process_ctes(), standard_planner(), and subquery_planner().

find_base_rel()

RelOptInfo * find_base_rel	(	PlannerInfo *	root,
		int	relid
	)

Definition at line 414 of file relnode.c.

{
    RelOptInfo *rel;
 
    /* use an unsigned comparison to prevent negative array element access */
    if ((uint32) relid < (uint32) root->simple_rel_array_size)
    {
        rel = root->simple_rel_array[relid];
        if (rel)
            return rel;
    }
 
    elog(ERROR, "no relation entry for relid %d", relid);
 
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, and root.

Referenced by add_base_clause_to_rel(), add_placeholders_to_base_rels(), add_vars_to_attr_needed(), add_vars_to_targetlist(), build_joinrel_tlist(), clause_selectivity_ext(), create_lateral_join_info(), distribute_row_identity_vars(), examine_simple_variable(), examine_variable(), expr_is_nonnullable(), finalize_plan(), find_childrel_parents(), find_join_input_rel(), find_single_rel_for_clauses(), get_foreign_key_join_selectivity(), get_matching_part_pairs(), get_rel_all_updated_cols(), get_translated_update_targetlist(), grouping_planner(), join_is_removable(), make_partition_pruneinfo(), make_partitionedrel_pruneinfo(), make_rel_from_joinlist(), postgresPlanForeignModify(), reduce_unique_semijoins(), remove_leftjoinrel_from_query(), set_append_rel_size(), set_base_rel_consider_startup(), set_subquery_size_estimates(), and set_subqueryscan_references().

find_base_rel_ignore_join()

RelOptInfo * find_base_rel_ignore_join	(	PlannerInfo *	root,
		int	relid
	)

Definition at line 454 of file relnode.c.

{
    /* use an unsigned comparison to prevent negative array element access */
    if ((uint32) relid < (uint32) root->simple_rel_array_size)
    {
        RelOptInfo *rel;
        RangeTblEntry *rte;
 
        rel = root->simple_rel_array[relid];
        if (rel)
            return rel;
 
        /*
         * We could just return NULL here, but for debugging purposes it seems
         * best to actually verify that the relid is an outer join and not
         * something weird.
         */
        rte = root->simple_rte_array[relid];
        if (rte && rte->rtekind == RTE_JOIN && rte->jointype != JOIN_INNER)
            return NULL;
    }
 
    elog(ERROR, "no relation entry for relid %d", relid);
 
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, JOIN_INNER, RangeTblEntry::jointype, root, RTE_JOIN, and RangeTblEntry::rtekind.

Referenced by add_join_clause_to_rels(), create_lateral_join_info(), find_appinfos_by_relids(), and remove_join_clause_from_rels().

find_base_rel_noerr()

RelOptInfo * find_base_rel_noerr	(	PlannerInfo *	root,
		int	relid
	)

Definition at line 436 of file relnode.c.

{
    /* use an unsigned comparison to prevent negative array element access */
    if ((uint32) relid < (uint32) root->simple_rel_array_size)
        return root->simple_rel_array[relid];
    return NULL;
}

References root.

Referenced by examine_simple_variable().

find_childrel_parents()

Relids find_childrel_parents	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 1509 of file relnode.c.

{
    Relids      result = NULL;
 
    Assert(rel->reloptkind == RELOPT_OTHER_MEMBER_REL);
    Assert(rel->relid > 0 && rel->relid < root->simple_rel_array_size);
 
    do
    {
        AppendRelInfo *appinfo = root->append_rel_array[rel->relid];
        Index       prelid = appinfo->parent_relid;
 
        result = bms_add_member(result, prelid);
 
        /* traverse up to the parent rel, loop if it's also a child rel */
        rel = find_base_rel(root, prelid);
    } while (rel->reloptkind == RELOPT_OTHER_MEMBER_REL);
 
    Assert(rel->reloptkind == RELOPT_BASEREL);
 
    return result;
}

References Assert(), bms_add_member(), find_base_rel(), AppendRelInfo::parent_relid, RelOptInfo::relid, RELOPT_BASEREL, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, and root.

Referenced by check_index_predicates(), and generate_implied_equalities_for_column().

find_join_rel()

RelOptInfo * find_join_rel	(	PlannerInfo *	root,
		Relids	relids
	)

Definition at line 527 of file relnode.c.

{
    /*
     * Switch to using hash lookup when list grows "too long".  The threshold
     * is arbitrary and is known only here.
     */
    if (!root->join_rel_hash && list_length(root->join_rel_list) > 32)
        build_join_rel_hash(root);
 
    /*
     * Use either hashtable lookup or linear search, as appropriate.
     *
     * Note: the seemingly redundant hashkey variable is used to avoid taking
     * the address of relids; unless the compiler is exceedingly smart, doing
     * so would force relids out of a register and thus probably slow down the
     * list-search case.
     */
    if (root->join_rel_hash)
    {
        Relids      hashkey = relids;
        JoinHashEntry *hentry;
 
        hentry = (JoinHashEntry *) hash_search(root->join_rel_hash,
                                               &hashkey,
                                               HASH_FIND,
                                               NULL);
        if (hentry)
            return hentry->join_rel;
    }
    else
    {
        ListCell   *l;
 
        foreach(l, root->join_rel_list)
        {
            RelOptInfo *rel = (RelOptInfo *) lfirst(l);
 
            if (bms_equal(rel->relids, relids))
                return rel;
        }
    }
 
    return NULL;
}

References bms_equal(), build_join_rel_hash(), HASH_FIND, hash_search(), JoinHashEntry::join_rel, lfirst, list_length(), RelOptInfo::relids, and root.

Referenced by build_child_join_rel(), build_join_rel(), examine_variable(), find_join_input_rel(), get_matching_part_pairs(), and postgresPlanDirectModify().

find_param_path_info()

ParamPathInfo * find_param_path_info	(	RelOptInfo *	rel,
		Relids	required_outer
	)

Definition at line 1889 of file relnode.c.

{
    ListCell   *lc;
 
    foreach(lc, rel->ppilist)
    {
        ParamPathInfo *ppi = (ParamPathInfo *) lfirst(lc);
 
        if (bms_equal(ppi->ppi_req_outer, required_outer))
            return ppi;
    }
 
    return NULL;
}

References bms_equal(), lfirst, ParamPathInfo::ppi_req_outer, and RelOptInfo::ppilist.

Referenced by get_appendrel_parampathinfo(), get_baserel_parampathinfo(), get_joinrel_parampathinfo(), and reparameterize_path_by_child().

get_appendrel_parampathinfo()

ParamPathInfo * get_appendrel_parampathinfo	(	RelOptInfo *	appendrel,
		Relids	required_outer
	)

Definition at line 1856 of file relnode.c.

{
    ParamPathInfo *ppi;
 
    /* If rel has LATERAL refs, every path for it should account for them */
    Assert(bms_is_subset(appendrel->lateral_relids, required_outer));
 
    /* Unparameterized paths have no ParamPathInfo */
    if (bms_is_empty(required_outer))
        return NULL;
 
    Assert(!bms_overlap(appendrel->relids, required_outer));
 
    /* If we already have a PPI for this parameterization, just return it */
    if ((ppi = find_param_path_info(appendrel, required_outer)))
        return ppi;
 
    /* Else build the ParamPathInfo */
    ppi = makeNode(ParamPathInfo);
    ppi->ppi_req_outer = required_outer;
    ppi->ppi_rows = 0;
    ppi->ppi_clauses = NIL;
    ppi->ppi_serials = NULL;
    appendrel->ppilist = lappend(appendrel->ppilist, ppi);
 
    return ppi;
}

References Assert(), bms_is_empty, bms_is_subset(), bms_overlap(), find_param_path_info(), lappend(), RelOptInfo::lateral_relids, makeNode, NIL, ParamPathInfo::ppi_clauses, ParamPathInfo::ppi_req_outer, ParamPathInfo::ppi_rows, ParamPathInfo::ppi_serials, RelOptInfo::ppilist, and RelOptInfo::relids.

Referenced by create_append_path().

get_baserel_parampathinfo()

ParamPathInfo * get_baserel_parampathinfo	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		Relids	required_outer
	)

Definition at line 1545 of file relnode.c.

{
    ParamPathInfo *ppi;
    Relids      joinrelids;
    List       *pclauses;
    List       *eqclauses;
    Bitmapset  *pserials;
    double      rows;
    ListCell   *lc;
 
    /* If rel has LATERAL refs, every path for it should account for them */
    Assert(bms_is_subset(baserel->lateral_relids, required_outer));
 
    /* Unparameterized paths have no ParamPathInfo */
    if (bms_is_empty(required_outer))
        return NULL;
 
    Assert(!bms_overlap(baserel->relids, required_outer));
 
    /* If we already have a PPI for this parameterization, just return it */
    if ((ppi = find_param_path_info(baserel, required_outer)))
        return ppi;
 
    /*
     * Identify all joinclauses that are movable to this base rel given this
     * parameterization.
     */
    joinrelids = bms_union(baserel->relids, required_outer);
    pclauses = NIL;
    foreach(lc, baserel->joininfo)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
        if (join_clause_is_movable_into(rinfo,
                                        baserel->relids,
                                        joinrelids))
            pclauses = lappend(pclauses, rinfo);
    }
 
    /*
     * Add in joinclauses generated by EquivalenceClasses, too.  (These
     * necessarily satisfy join_clause_is_movable_into; but in assert-enabled
     * builds, let's verify that.)
     */
    eqclauses = generate_join_implied_equalities(root,
                                                 joinrelids,
                                                 required_outer,
                                                 baserel,
                                                 NULL);
#ifdef USE_ASSERT_CHECKING
    foreach(lc, eqclauses)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
        Assert(join_clause_is_movable_into(rinfo,
                                           baserel->relids,
                                           joinrelids));
    }
#endif
    pclauses = list_concat(pclauses, eqclauses);
 
    /* Compute set of serial numbers of the enforced clauses */
    pserials = NULL;
    foreach(lc, pclauses)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
        pserials = bms_add_member(pserials, rinfo->rinfo_serial);
    }
 
    /* Estimate the number of rows returned by the parameterized scan */
    rows = get_parameterized_baserel_size(root, baserel, pclauses);
 
    /* And now we can build the ParamPathInfo */
    ppi = makeNode(ParamPathInfo);
    ppi->ppi_req_outer = required_outer;
    ppi->ppi_rows = rows;
    ppi->ppi_clauses = pclauses;
    ppi->ppi_serials = pserials;
    baserel->ppilist = lappend(baserel->ppilist, ppi);
 
    return ppi;
}

References Assert(), bms_add_member(), bms_is_empty, bms_is_subset(), bms_overlap(), bms_union(), find_param_path_info(), generate_join_implied_equalities(), get_parameterized_baserel_size(), join_clause_is_movable_into(), RelOptInfo::joininfo, lappend(), RelOptInfo::lateral_relids, lfirst, list_concat(), makeNode, NIL, ParamPathInfo::ppi_clauses, ParamPathInfo::ppi_req_outer, ParamPathInfo::ppi_rows, ParamPathInfo::ppi_serials, RelOptInfo::ppilist, RelOptInfo::relids, RestrictInfo::rinfo_serial, and root.

Referenced by create_append_path(), create_bitmap_and_path(), create_bitmap_heap_path(), create_bitmap_or_path(), create_ctescan_path(), create_foreignscan_path(), create_functionscan_path(), create_gather_merge_path(), create_gather_path(), create_index_path(), create_namedtuplestorescan_path(), create_resultscan_path(), create_samplescan_path(), create_seqscan_path(), create_subqueryscan_path(), create_tablefuncscan_path(), create_tidrangescan_path(), create_tidscan_path(), create_valuesscan_path(), create_worktablescan_path(), postgresGetForeignPaths(), and reparameterize_path().

get_joinrel_parampathinfo()

ParamPathInfo * get_joinrel_parampathinfo	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		Path *	outer_path,
		Path *	inner_path,
		SpecialJoinInfo *	sjinfo,
		Relids	required_outer,
		List **	restrict_clauses
	)

Definition at line 1659 of file relnode.c.

{
    ParamPathInfo *ppi;
    Relids      join_and_req;
    Relids      outer_and_req;
    Relids      inner_and_req;
    List       *pclauses;
    List       *eclauses;
    List       *dropped_ecs;
    double      rows;
    ListCell   *lc;
 
    /* If rel has LATERAL refs, every path for it should account for them */
    Assert(bms_is_subset(joinrel->lateral_relids, required_outer));
 
    /* Unparameterized paths have no ParamPathInfo or extra join clauses */
    if (bms_is_empty(required_outer))
        return NULL;
 
    Assert(!bms_overlap(joinrel->relids, required_outer));
 
    /*
     * Identify all joinclauses that are movable to this join rel given this
     * parameterization.  These are the clauses that are movable into this
     * join, but not movable into either input path.  Treat an unparameterized
     * input path as not accepting parameterized clauses (because it won't,
     * per the shortcut exit above), even though the joinclause movement rules
     * might allow the same clauses to be moved into a parameterized path for
     * that rel.
     */
    join_and_req = bms_union(joinrel->relids, required_outer);
    if (outer_path->param_info)
        outer_and_req = bms_union(outer_path->parent->relids,
                                  PATH_REQ_OUTER(outer_path));
    else
        outer_and_req = NULL;   /* outer path does not accept parameters */
    if (inner_path->param_info)
        inner_and_req = bms_union(inner_path->parent->relids,
                                  PATH_REQ_OUTER(inner_path));
    else
        inner_and_req = NULL;   /* inner path does not accept parameters */
 
    pclauses = NIL;
    foreach(lc, joinrel->joininfo)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
        if (join_clause_is_movable_into(rinfo,
                                        joinrel->relids,
                                        join_and_req) &&
            !join_clause_is_movable_into(rinfo,
                                         outer_path->parent->relids,
                                         outer_and_req) &&
            !join_clause_is_movable_into(rinfo,
                                         inner_path->parent->relids,
                                         inner_and_req))
            pclauses = lappend(pclauses, rinfo);
    }
 
    /* Consider joinclauses generated by EquivalenceClasses, too */
    eclauses = generate_join_implied_equalities(root,
                                                join_and_req,
                                                required_outer,
                                                joinrel,
                                                NULL);
    /* We only want ones that aren't movable to lower levels */
    dropped_ecs = NIL;
    foreach(lc, eclauses)
    {
        RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
        Assert(join_clause_is_movable_into(rinfo,
                                           joinrel->relids,
                                           join_and_req));
        if (join_clause_is_movable_into(rinfo,
                                        outer_path->parent->relids,
                                        outer_and_req))
            continue;           /* drop if movable into LHS */
        if (join_clause_is_movable_into(rinfo,
                                        inner_path->parent->relids,
                                        inner_and_req))
        {
            /* drop if movable into RHS, but remember EC for use below */
            Assert(rinfo->left_ec == rinfo->right_ec);
            dropped_ecs = lappend(dropped_ecs, rinfo->left_ec);
            continue;
        }
        pclauses = lappend(pclauses, rinfo);
    }
 
    /*
     * EquivalenceClasses are harder to deal with than we could wish, because
     * of the fact that a given EC can generate different clauses depending on
     * context.  Suppose we have an EC {X.X, Y.Y, Z.Z} where X and Y are the
     * LHS and RHS of the current join and Z is in required_outer, and further
     * suppose that the inner_path is parameterized by both X and Z.  The code
     * above will have produced either Z.Z = X.X or Z.Z = Y.Y from that EC,
     * and in the latter case will have discarded it as being movable into the
     * RHS.  However, the EC machinery might have produced either Y.Y = X.X or
     * Y.Y = Z.Z as the EC enforcement clause within the inner_path; it will
     * not have produced both, and we can't readily tell from here which one
     * it did pick.  If we add no clause to this join, we'll end up with
     * insufficient enforcement of the EC; either Z.Z or X.X will fail to be
     * constrained to be equal to the other members of the EC.  (When we come
     * to join Z to this X/Y path, we will certainly drop whichever EC clause
     * is generated at that join, so this omission won't get fixed later.)
     *
     * To handle this, for each EC we discarded such a clause from, try to
     * generate a clause connecting the required_outer rels to the join's LHS
     * ("Z.Z = X.X" in the terms of the above example).  If successful, and if
     * the clause can't be moved to the LHS, add it to the current join's
     * restriction clauses.  (If an EC cannot generate such a clause then it
     * has nothing that needs to be enforced here, while if the clause can be
     * moved into the LHS then it should have been enforced within that path.)
     *
     * Note that we don't need similar processing for ECs whose clause was
     * considered to be movable into the LHS, because the LHS can't refer to
     * the RHS so there is no comparable ambiguity about what it might
     * actually be enforcing internally.
     */
    if (dropped_ecs)
    {
        Relids      real_outer_and_req;
 
        real_outer_and_req = bms_union(outer_path->parent->relids,
                                       required_outer);
        eclauses =
            generate_join_implied_equalities_for_ecs(root,
                                                     dropped_ecs,
                                                     real_outer_and_req,
                                                     required_outer,
                                                     outer_path->parent);
        foreach(lc, eclauses)
        {
            RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
            Assert(join_clause_is_movable_into(rinfo,
                                               outer_path->parent->relids,
                                               real_outer_and_req));
            if (!join_clause_is_movable_into(rinfo,
                                             outer_path->parent->relids,
                                             outer_and_req))
                pclauses = lappend(pclauses, rinfo);
        }
    }
 
    /*
     * Now, attach the identified moved-down clauses to the caller's
     * restrict_clauses list.  By using list_concat in this order, we leave
     * the original list structure of restrict_clauses undamaged.
     */
    *restrict_clauses = list_concat(pclauses, *restrict_clauses);
 
    /* If we already have a PPI for this parameterization, just return it */
    if ((ppi = find_param_path_info(joinrel, required_outer)))
        return ppi;
 
    /* Estimate the number of rows returned by the parameterized join */
    rows = get_parameterized_joinrel_size(root, joinrel,
                                          outer_path,
                                          inner_path,
                                          sjinfo,
                                          *restrict_clauses);
 
    /*
     * And now we can build the ParamPathInfo.  No point in saving the
     * input-pair-dependent clause list, though.
     *
     * Note: in GEQO mode, we'll be called in a temporary memory context, but
     * the joinrel structure is there too, so no problem.
     */
    ppi = makeNode(ParamPathInfo);
    ppi->ppi_req_outer = required_outer;
    ppi->ppi_rows = rows;
    ppi->ppi_clauses = NIL;
    ppi->ppi_serials = NULL;
    joinrel->ppilist = lappend(joinrel->ppilist, ppi);
 
    return ppi;
}

References Assert(), bms_is_empty, bms_is_subset(), bms_overlap(), bms_union(), find_param_path_info(), generate_join_implied_equalities(), generate_join_implied_equalities_for_ecs(), get_parameterized_joinrel_size(), join_clause_is_movable_into(), RelOptInfo::joininfo, lappend(), RelOptInfo::lateral_relids, lfirst, list_concat(), makeNode, NIL, PATH_REQ_OUTER, ParamPathInfo::ppi_clauses, ParamPathInfo::ppi_req_outer, ParamPathInfo::ppi_rows, ParamPathInfo::ppi_serials, RelOptInfo::ppilist, RelOptInfo::relids, and root.

Referenced by create_hashjoin_path(), create_mergejoin_path(), and create_nestloop_path().

get_param_path_clause_serials()

Bitmapset * get_param_path_clause_serials

(

Path *

path

)

Definition at line 1910 of file relnode.c.

{
    if (path->param_info == NULL)
        return NULL;            /* not parameterized */
 
    /*
     * We don't currently support parameterized MergeAppend paths, as
     * explained in the comments for generate_orderedappend_paths.
     */
    Assert(!IsA(path, MergeAppendPath));
 
    if (IsA(path, NestPath) ||
        IsA(path, MergePath) ||
        IsA(path, HashPath))
    {
        /*
         * For a join path, combine clauses enforced within either input path
         * with those enforced as joinrestrictinfo in this path.  Note that
         * joinrestrictinfo may include some non-pushed-down clauses, but for
         * current purposes it's okay if we include those in the result. (To
         * be more careful, we could check for clause_relids overlapping the
         * path parameterization, but it's not worth the cycles for now.)
         */
        JoinPath   *jpath = (JoinPath *) path;
        Bitmapset  *pserials;
        ListCell   *lc;
 
        pserials = NULL;
        pserials = bms_add_members(pserials,
                                   get_param_path_clause_serials(jpath->outerjoinpath));
        pserials = bms_add_members(pserials,
                                   get_param_path_clause_serials(jpath->innerjoinpath));
        foreach(lc, jpath->joinrestrictinfo)
        {
            RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
 
            pserials = bms_add_member(pserials, rinfo->rinfo_serial);
        }
        return pserials;
    }
    else if (IsA(path, AppendPath))
    {
        /*
         * For an appendrel, take the intersection of the sets of clauses
         * enforced in each input path.
         */
        AppendPath *apath = (AppendPath *) path;
        Bitmapset  *pserials;
        ListCell   *lc;
 
        pserials = NULL;
        foreach(lc, apath->subpaths)
        {
            Path       *subpath = (Path *) lfirst(lc);
            Bitmapset  *subserials;
 
            subserials = get_param_path_clause_serials(subpath);
            if (lc == list_head(apath->subpaths))
                pserials = bms_copy(subserials);
            else
                pserials = bms_int_members(pserials, subserials);
        }
        return pserials;
    }
    else
    {
        /*
         * Otherwise, it's a baserel path and we can use the
         * previously-computed set of serial numbers.
         */
        return path->param_info->ppi_serials;
    }
}

References Assert(), bms_add_member(), bms_add_members(), bms_copy(), bms_int_members(), get_param_path_clause_serials(), JoinPath::innerjoinpath, IsA, JoinPath::joinrestrictinfo, lfirst, list_head(), JoinPath::outerjoinpath, RestrictInfo::rinfo_serial, subpath(), and AppendPath::subpaths.

Referenced by create_nestloop_path(), and get_param_path_clause_serials().

min_join_parameterization()

Relids min_join_parameterization	(	PlannerInfo *	root,
		Relids	joinrelids,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel
	)

Definition at line 1022 of file relnode.c.

{
    Relids      result;
 
    /*
     * Basically we just need the union of the inputs' lateral_relids, less
     * whatever is already in the join.
     *
     * It's not immediately obvious that this is a valid way to compute the
     * result, because it might seem that we're ignoring possible lateral refs
     * of PlaceHolderVars that are due to be computed at the join but not in
     * either input.  However, because create_lateral_join_info() already
     * charged all such PHV refs to each member baserel of the join, they'll
     * be accounted for already in the inputs' lateral_relids.  Likewise, we
     * do not need to worry about doing transitive closure here, because that
     * was already accounted for in the original baserel lateral_relids.
     */
    result = bms_union(outer_rel->lateral_relids, inner_rel->lateral_relids);
    result = bms_del_members(result, joinrelids);
    return result;
}

References bms_del_members(), bms_union(), and RelOptInfo::lateral_relids.

Referenced by build_join_rel(), and join_is_legal().

path_is_reparameterizable_by_child()

bool path_is_reparameterizable_by_child	(	Path *	path,
		RelOptInfo *	child_rel
	)

Definition at line 4568 of file pathnode.c.

{
#define REJECT_IF_PATH_NOT_REPARAMETERIZABLE(path) \
do { \
    if (!path_is_reparameterizable_by_child(path, child_rel)) \
        return false; \
} while(0)
 
#define REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(pathlist) \
do { \
    if (!pathlist_is_reparameterizable_by_child(pathlist, child_rel)) \
        return false; \
} while(0)
 
    /*
     * If the path is not parameterized by the parent of the given relation,
     * it doesn't need reparameterization.
     */
    if (!path->param_info ||
        !bms_overlap(PATH_REQ_OUTER(path), child_rel->top_parent_relids))
        return true;
 
    /*
     * Check that the path type is one that reparameterize_path_by_child() can
     * handle, and recursively check subpaths.
     */
    switch (nodeTag(path))
    {
        case T_Path:
        case T_IndexPath:
            break;
 
        case T_BitmapHeapPath:
            {
                BitmapHeapPath *bhpath = (BitmapHeapPath *) path;
 
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(bhpath->bitmapqual);
            }
            break;
 
        case T_BitmapAndPath:
            {
                BitmapAndPath *bapath = (BitmapAndPath *) path;
 
                REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(bapath->bitmapquals);
            }
            break;
 
        case T_BitmapOrPath:
            {
                BitmapOrPath *bopath = (BitmapOrPath *) path;
 
                REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(bopath->bitmapquals);
            }
            break;
 
        case T_ForeignPath:
            {
                ForeignPath *fpath = (ForeignPath *) path;
 
                if (fpath->fdw_outerpath)
                    REJECT_IF_PATH_NOT_REPARAMETERIZABLE(fpath->fdw_outerpath);
            }
            break;
 
        case T_CustomPath:
            {
                CustomPath *cpath = (CustomPath *) path;
 
                REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(cpath->custom_paths);
            }
            break;
 
        case T_NestPath:
        case T_MergePath:
        case T_HashPath:
            {
                JoinPath   *jpath = (JoinPath *) path;
 
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(jpath->outerjoinpath);
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(jpath->innerjoinpath);
            }
            break;
 
        case T_AppendPath:
            {
                AppendPath *apath = (AppendPath *) path;
 
                REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE(apath->subpaths);
            }
            break;
 
        case T_MaterialPath:
            {
                MaterialPath *mpath = (MaterialPath *) path;
 
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(mpath->subpath);
            }
            break;
 
        case T_MemoizePath:
            {
                MemoizePath *mpath = (MemoizePath *) path;
 
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(mpath->subpath);
            }
            break;
 
        case T_GatherPath:
            {
                GatherPath *gpath = (GatherPath *) path;
 
                REJECT_IF_PATH_NOT_REPARAMETERIZABLE(gpath->subpath);
            }
            break;
 
        default:
            /* We don't know how to reparameterize this path. */
            return false;
    }
 
    return true;
}

References BitmapHeapPath::bitmapqual, BitmapAndPath::bitmapquals, BitmapOrPath::bitmapquals, bms_overlap(), CustomPath::custom_paths, ForeignPath::fdw_outerpath, JoinPath::innerjoinpath, nodeTag, JoinPath::outerjoinpath, PATH_REQ_OUTER, REJECT_IF_PATH_LIST_NOT_REPARAMETERIZABLE, REJECT_IF_PATH_NOT_REPARAMETERIZABLE, MaterialPath::subpath, MemoizePath::subpath, GatherPath::subpath, AppendPath::subpaths, and RelOptInfo::top_parent_relids.

Referenced by pathlist_is_reparameterizable_by_child(), try_nestloop_path(), and try_partial_nestloop_path().

reparameterize_path()

Path * reparameterize_path	(	PlannerInfo *	root,
		Path *	path,
		Relids	required_outer,
		double	loop_count
	)

Definition at line 4106 of file pathnode.c.

{
    RelOptInfo *rel = path->parent;
 
    /* Can only increase, not decrease, path's parameterization */
    if (!bms_is_subset(PATH_REQ_OUTER(path), required_outer))
        return NULL;
    switch (path->pathtype)
    {
        case T_SeqScan:
            return create_seqscan_path(root, rel, required_outer, 0);
        case T_SampleScan:
            return (Path *) create_samplescan_path(root, rel, required_outer);
        case T_IndexScan:
        case T_IndexOnlyScan:
            {
                IndexPath  *ipath = (IndexPath *) path;
                IndexPath  *newpath = makeNode(IndexPath);
 
                /*
                 * We can't use create_index_path directly, and would not want
                 * to because it would re-compute the indexqual conditions
                 * which is wasted effort.  Instead we hack things a bit:
                 * flat-copy the path node, revise its param_info, and redo
                 * the cost estimate.
                 */
                memcpy(newpath, ipath, sizeof(IndexPath));
                newpath->path.param_info =
                    get_baserel_parampathinfo(root, rel, required_outer);
                cost_index(newpath, root, loop_count, false);
                return (Path *) newpath;
            }
        case T_BitmapHeapScan:
            {
                BitmapHeapPath *bpath = (BitmapHeapPath *) path;
 
                return (Path *) create_bitmap_heap_path(root,
                                                        rel,
                                                        bpath->bitmapqual,
                                                        required_outer,
                                                        loop_count, 0);
            }
        case T_SubqueryScan:
            {
                SubqueryScanPath *spath = (SubqueryScanPath *) path;
                Path       *subpath = spath->subpath;
                bool        trivial_pathtarget;
 
                /*
                 * If existing node has zero extra cost, we must have decided
                 * its target is trivial.  (The converse is not true, because
                 * it might have a trivial target but quals to enforce; but in
                 * that case the new node will too, so it doesn't matter
                 * whether we get the right answer here.)
                 */
                trivial_pathtarget =
                    (subpath->total_cost == spath->path.total_cost);
 
                return (Path *) create_subqueryscan_path(root,
                                                         rel,
                                                         subpath,
                                                         trivial_pathtarget,
                                                         spath->path.pathkeys,
                                                         required_outer);
            }
        case T_Result:
            /* Supported only for RTE_RESULT scan paths */
            if (IsA(path, Path))
                return create_resultscan_path(root, rel, required_outer);
            break;
        case T_Append:
            {
                AppendPath *apath = (AppendPath *) path;
                List       *childpaths = NIL;
                List       *partialpaths = NIL;
                int         i;
                ListCell   *lc;
 
                /* Reparameterize the children */
                i = 0;
                foreach(lc, apath->subpaths)
                {
                    Path       *spath = (Path *) lfirst(lc);
 
                    spath = reparameterize_path(root, spath,
                                                required_outer,
                                                loop_count);
                    if (spath == NULL)
                        return NULL;
                    /* We have to re-split the regular and partial paths */
                    if (i < apath->first_partial_path)
                        childpaths = lappend(childpaths, spath);
                    else
                        partialpaths = lappend(partialpaths, spath);
                    i++;
                }
                return (Path *)
                    create_append_path(root, rel, childpaths, partialpaths,
                                       apath->path.pathkeys, required_outer,
                                       apath->path.parallel_workers,
                                       apath->path.parallel_aware,
                                       -1);
            }
        case T_Material:
            {
                MaterialPath *mpath = (MaterialPath *) path;
                Path       *spath = mpath->subpath;
 
                spath = reparameterize_path(root, spath,
                                            required_outer,
                                            loop_count);
                if (spath == NULL)
                    return NULL;
                return (Path *) create_material_path(rel, spath);
            }
        case T_Memoize:
            {
                MemoizePath *mpath = (MemoizePath *) path;
                Path       *spath = mpath->subpath;
 
                spath = reparameterize_path(root, spath,
                                            required_outer,
                                            loop_count);
                if (spath == NULL)
                    return NULL;
                return (Path *) create_memoize_path(root, rel,
                                                    spath,
                                                    mpath->param_exprs,
                                                    mpath->hash_operators,
                                                    mpath->singlerow,
                                                    mpath->binary_mode,
                                                    mpath->calls);
            }
        default:
            break;
    }
    return NULL;
}

References MemoizePath::binary_mode, BitmapHeapPath::bitmapqual, bms_is_subset(), MemoizePath::calls, cost_index(), create_append_path(), create_bitmap_heap_path(), create_material_path(), create_memoize_path(), create_resultscan_path(), create_samplescan_path(), create_seqscan_path(), create_subqueryscan_path(), get_baserel_parampathinfo(), MemoizePath::hash_operators, i, IsA, lappend(), lfirst, makeNode, NIL, Path::parallel_aware, Path::parallel_workers, MemoizePath::param_exprs, IndexPath::path, SubqueryScanPath::path, AppendPath::path, PATH_REQ_OUTER, Path::pathkeys, Path::pathtype, reparameterize_path(), root, MemoizePath::singlerow, subpath(), SubqueryScanPath::subpath, MaterialPath::subpath, MemoizePath::subpath, AppendPath::subpaths, and Path::total_cost.

Referenced by get_cheapest_parameterized_child_path(), and reparameterize_path().

reparameterize_path_by_child()

Path * reparameterize_path_by_child	(	PlannerInfo *	root,
		Path *	path,
		RelOptInfo *	child_rel
	)

Definition at line 4272 of file pathnode.c.

{
    Path       *new_path;
    ParamPathInfo *new_ppi;
    ParamPathInfo *old_ppi;
    Relids      required_outer;
 
#define ADJUST_CHILD_ATTRS(node) \
    ((node) = (void *) adjust_appendrel_attrs_multilevel(root, \
                                                         (Node *) (node), \
                                                         child_rel, \
                                                         child_rel->top_parent))
 
#define REPARAMETERIZE_CHILD_PATH(path) \
do { \
    (path) = reparameterize_path_by_child(root, (path), child_rel); \
    if ((path) == NULL) \
        return NULL; \
} while(0)
 
#define REPARAMETERIZE_CHILD_PATH_LIST(pathlist) \
do { \
    if ((pathlist) != NIL) \
    { \
        (pathlist) = reparameterize_pathlist_by_child(root, (pathlist), \
                                                      child_rel); \
        if ((pathlist) == NIL) \
            return NULL; \
    } \
} while(0)
 
    /*
     * If the path is not parameterized by the parent of the given relation,
     * it doesn't need reparameterization.
     */
    if (!path->param_info ||
        !bms_overlap(PATH_REQ_OUTER(path), child_rel->top_parent_relids))
        return path;
 
    /*
     * If possible, reparameterize the given path.
     *
     * This function is currently only applied to the inner side of a nestloop
     * join that is being partitioned by the partitionwise-join code.  Hence,
     * we need only support path types that plausibly arise in that context.
     * (In particular, supporting sorted path types would be a waste of code
     * and cycles: even if we translated them here, they'd just lose in
     * subsequent cost comparisons.)  If we do see an unsupported path type,
     * that just means we won't be able to generate a partitionwise-join plan
     * using that path type.
     */
    switch (nodeTag(path))
    {
        case T_Path:
            new_path = path;
            ADJUST_CHILD_ATTRS(new_path->parent->baserestrictinfo);
            if (path->pathtype == T_SampleScan)
            {
                Index       scan_relid = path->parent->relid;
                RangeTblEntry *rte;
 
                /* 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);
                Assert(rte->tablesample != NULL);
 
                ADJUST_CHILD_ATTRS(rte->tablesample);
            }
            break;
 
        case T_IndexPath:
            {
                IndexPath  *ipath = (IndexPath *) path;
 
                ADJUST_CHILD_ATTRS(ipath->indexinfo->indrestrictinfo);
                ADJUST_CHILD_ATTRS(ipath->indexclauses);
                new_path = (Path *) ipath;
            }
            break;
 
        case T_BitmapHeapPath:
            {
                BitmapHeapPath *bhpath = (BitmapHeapPath *) path;
 
                ADJUST_CHILD_ATTRS(bhpath->path.parent->baserestrictinfo);
                REPARAMETERIZE_CHILD_PATH(bhpath->bitmapqual);
                new_path = (Path *) bhpath;
            }
            break;
 
        case T_BitmapAndPath:
            {
                BitmapAndPath *bapath = (BitmapAndPath *) path;
 
                REPARAMETERIZE_CHILD_PATH_LIST(bapath->bitmapquals);
                new_path = (Path *) bapath;
            }
            break;
 
        case T_BitmapOrPath:
            {
                BitmapOrPath *bopath = (BitmapOrPath *) path;
 
                REPARAMETERIZE_CHILD_PATH_LIST(bopath->bitmapquals);
                new_path = (Path *) bopath;
            }
            break;
 
        case T_ForeignPath:
            {
                ForeignPath *fpath = (ForeignPath *) path;
                ReparameterizeForeignPathByChild_function rfpc_func;
 
                ADJUST_CHILD_ATTRS(fpath->path.parent->baserestrictinfo);
                if (fpath->fdw_outerpath)
                    REPARAMETERIZE_CHILD_PATH(fpath->fdw_outerpath);
                if (fpath->fdw_restrictinfo)
                    ADJUST_CHILD_ATTRS(fpath->fdw_restrictinfo);
 
                /* Hand over to FDW if needed. */
                rfpc_func =
                    path->parent->fdwroutine->ReparameterizeForeignPathByChild;
                if (rfpc_func)
                    fpath->fdw_private = rfpc_func(root, fpath->fdw_private,
                                                   child_rel);
                new_path = (Path *) fpath;
            }
            break;
 
        case T_CustomPath:
            {
                CustomPath *cpath = (CustomPath *) path;
 
                ADJUST_CHILD_ATTRS(cpath->path.parent->baserestrictinfo);
                REPARAMETERIZE_CHILD_PATH_LIST(cpath->custom_paths);
                if (cpath->custom_restrictinfo)
                    ADJUST_CHILD_ATTRS(cpath->custom_restrictinfo);
                if (cpath->methods &&
                    cpath->methods->ReparameterizeCustomPathByChild)
                    cpath->custom_private =
                        cpath->methods->ReparameterizeCustomPathByChild(root,
                                                                        cpath->custom_private,
                                                                        child_rel);
                new_path = (Path *) cpath;
            }
            break;
 
        case T_NestPath:
            {
                NestPath   *npath = (NestPath *) path;
                JoinPath   *jpath = (JoinPath *) npath;
 
                REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
                REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
                ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
                new_path = (Path *) npath;
            }
            break;
 
        case T_MergePath:
            {
                MergePath  *mpath = (MergePath *) path;
                JoinPath   *jpath = (JoinPath *) mpath;
 
                REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
                REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
                ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
                ADJUST_CHILD_ATTRS(mpath->path_mergeclauses);
                new_path = (Path *) mpath;
            }
            break;
 
        case T_HashPath:
            {
                HashPath   *hpath = (HashPath *) path;
                JoinPath   *jpath = (JoinPath *) hpath;
 
                REPARAMETERIZE_CHILD_PATH(jpath->outerjoinpath);
                REPARAMETERIZE_CHILD_PATH(jpath->innerjoinpath);
                ADJUST_CHILD_ATTRS(jpath->joinrestrictinfo);
                ADJUST_CHILD_ATTRS(hpath->path_hashclauses);
                new_path = (Path *) hpath;
            }
            break;
 
        case T_AppendPath:
            {
                AppendPath *apath = (AppendPath *) path;
 
                REPARAMETERIZE_CHILD_PATH_LIST(apath->subpaths);
                new_path = (Path *) apath;
            }
            break;
 
        case T_MaterialPath:
            {
                MaterialPath *mpath = (MaterialPath *) path;
 
                REPARAMETERIZE_CHILD_PATH(mpath->subpath);
                new_path = (Path *) mpath;
            }
            break;
 
        case T_MemoizePath:
            {
                MemoizePath *mpath = (MemoizePath *) path;
 
                REPARAMETERIZE_CHILD_PATH(mpath->subpath);
                ADJUST_CHILD_ATTRS(mpath->param_exprs);
                new_path = (Path *) mpath;
            }
            break;
 
        case T_GatherPath:
            {
                GatherPath *gpath = (GatherPath *) path;
 
                REPARAMETERIZE_CHILD_PATH(gpath->subpath);
                new_path = (Path *) gpath;
            }
            break;
 
        default:
            /* We don't know how to reparameterize this path. */
            return NULL;
    }
 
    /*
     * Adjust the parameterization information, which refers to the topmost
     * parent. The topmost parent can be multiple levels away from the given
     * child, hence use multi-level expression adjustment routines.
     */
    old_ppi = new_path->param_info;
    required_outer =
        adjust_child_relids_multilevel(root, old_ppi->ppi_req_outer,
                                       child_rel,
                                       child_rel->top_parent);
 
    /* If we already have a PPI for this parameterization, just return it */
    new_ppi = find_param_path_info(new_path->parent, required_outer);
 
    /*
     * If not, build a new one and link it to the list of PPIs. For the same
     * reason as explained in mark_dummy_rel(), allocate new PPI in the same
     * context the given RelOptInfo is in.
     */
    if (new_ppi == NULL)
    {
        MemoryContext oldcontext;
        RelOptInfo *rel = path->parent;
 
        oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(rel));
 
        new_ppi = makeNode(ParamPathInfo);
        new_ppi->ppi_req_outer = bms_copy(required_outer);
        new_ppi->ppi_rows = old_ppi->ppi_rows;
        new_ppi->ppi_clauses = old_ppi->ppi_clauses;
        ADJUST_CHILD_ATTRS(new_ppi->ppi_clauses);
        new_ppi->ppi_serials = bms_copy(old_ppi->ppi_serials);
        rel->ppilist = lappend(rel->ppilist, new_ppi);
 
        MemoryContextSwitchTo(oldcontext);
    }
    bms_free(required_outer);
 
    new_path->param_info = new_ppi;
 
    /*
     * Adjust the path target if the parent of the outer relation is
     * referenced in the targetlist. This can happen when only the parent of
     * outer relation is laterally referenced in this relation.
     */
    if (bms_overlap(path->parent->lateral_relids,
                    child_rel->top_parent_relids))
    {
        new_path->pathtarget = copy_pathtarget(new_path->pathtarget);
        ADJUST_CHILD_ATTRS(new_path->pathtarget->exprs);
    }
 
    return new_path;
}

References ADJUST_CHILD_ATTRS, adjust_child_relids_multilevel(), Assert(), BitmapHeapPath::bitmapqual, BitmapAndPath::bitmapquals, BitmapOrPath::bitmapquals, bms_copy(), bms_free(), bms_overlap(), copy_pathtarget(), CustomPath::custom_paths, CustomPath::custom_private, CustomPath::custom_restrictinfo, ForeignPath::fdw_outerpath, ForeignPath::fdw_private, ForeignPath::fdw_restrictinfo, find_param_path_info(), GetMemoryChunkContext(), IndexPath::indexclauses, IndexPath::indexinfo, IndexOptInfo::indrestrictinfo, JoinPath::innerjoinpath, JoinPath::joinrestrictinfo, lappend(), makeNode, MemoryContextSwitchTo(), CustomPath::methods, nodeTag, JoinPath::outerjoinpath, MemoizePath::param_exprs, BitmapHeapPath::path, ForeignPath::path, CustomPath::path, HashPath::path_hashclauses, MergePath::path_mergeclauses, PATH_REQ_OUTER, Path::pathtype, planner_rt_fetch, ParamPathInfo::ppi_clauses, ParamPathInfo::ppi_req_outer, ParamPathInfo::ppi_rows, ParamPathInfo::ppi_serials, RelOptInfo::ppilist, REPARAMETERIZE_CHILD_PATH, REPARAMETERIZE_CHILD_PATH_LIST, CustomPathMethods::ReparameterizeCustomPathByChild, root, RTE_RELATION, RangeTblEntry::rtekind, MaterialPath::subpath, MemoizePath::subpath, GatherPath::subpath, AppendPath::subpaths, RangeTblEntry::tablesample, and RelOptInfo::top_parent_relids.

Referenced by create_nestloop_plan(), and reparameterize_pathlist_by_child().

set_cheapest()

void set_cheapest

(

RelOptInfo *

parent_rel

)

Definition at line 269 of file pathnode.c.

{
    Path       *cheapest_startup_path;
    Path       *cheapest_total_path;
    Path       *best_param_path;
    List       *parameterized_paths;
    ListCell   *p;
 
    Assert(IsA(parent_rel, RelOptInfo));
 
    if (parent_rel->pathlist == NIL)
        elog(ERROR, "could not devise a query plan for the given query");
 
    cheapest_startup_path = cheapest_total_path = best_param_path = NULL;
    parameterized_paths = NIL;
 
    foreach(p, parent_rel->pathlist)
    {
        Path       *path = (Path *) lfirst(p);
        int         cmp;
 
        if (path->param_info)
        {
            /* Parameterized path, so add it to parameterized_paths */
            parameterized_paths = lappend(parameterized_paths, path);
 
            /*
             * If we have an unparameterized cheapest-total, we no longer care
             * about finding the best parameterized path, so move on.
             */
            if (cheapest_total_path)
                continue;
 
            /*
             * Otherwise, track the best parameterized path, which is the one
             * with least total cost among those of the minimum
             * parameterization.
             */
            if (best_param_path == NULL)
                best_param_path = path;
            else
            {
                switch (bms_subset_compare(PATH_REQ_OUTER(path),
                                           PATH_REQ_OUTER(best_param_path)))
                {
                    case BMS_EQUAL:
                        /* keep the cheaper one */
                        if (compare_path_costs(path, best_param_path,
                                               TOTAL_COST) < 0)
                            best_param_path = path;
                        break;
                    case BMS_SUBSET1:
                        /* new path is less-parameterized */
                        best_param_path = path;
                        break;
                    case BMS_SUBSET2:
                        /* old path is less-parameterized, keep it */
                        break;
                    case BMS_DIFFERENT:
 
                        /*
                         * This means that neither path has the least possible
                         * parameterization for the rel.  We'll sit on the old
                         * path until something better comes along.
                         */
                        break;
                }
            }
        }
        else
        {
            /* Unparameterized path, so consider it for cheapest slots */
            if (cheapest_total_path == NULL)
            {
                cheapest_startup_path = cheapest_total_path = path;
                continue;
            }
 
            /*
             * If we find two paths of identical costs, try to keep the
             * better-sorted one.  The paths might have unrelated sort
             * orderings, in which case we can only guess which might be
             * better to keep, but if one is superior then we definitely
             * should keep that one.
             */
            cmp = compare_path_costs(cheapest_startup_path, path, STARTUP_COST);
            if (cmp > 0 ||
                (cmp == 0 &&
                 compare_pathkeys(cheapest_startup_path->pathkeys,
                                  path->pathkeys) == PATHKEYS_BETTER2))
                cheapest_startup_path = path;
 
            cmp = compare_path_costs(cheapest_total_path, path, TOTAL_COST);
            if (cmp > 0 ||
                (cmp == 0 &&
                 compare_pathkeys(cheapest_total_path->pathkeys,
                                  path->pathkeys) == PATHKEYS_BETTER2))
                cheapest_total_path = path;
        }
    }
 
    /* Add cheapest unparameterized path, if any, to parameterized_paths */
    if (cheapest_total_path)
        parameterized_paths = lcons(cheapest_total_path, parameterized_paths);
 
    /*
     * If there is no unparameterized path, use the best parameterized path as
     * cheapest_total_path (but not as cheapest_startup_path).
     */
    if (cheapest_total_path == NULL)
        cheapest_total_path = best_param_path;
    Assert(cheapest_total_path != NULL);
 
    parent_rel->cheapest_startup_path = cheapest_startup_path;
    parent_rel->cheapest_total_path = cheapest_total_path;
    parent_rel->cheapest_unique_path = NULL;    /* computed only if needed */
    parent_rel->cheapest_parameterized_paths = parameterized_paths;
}

References Assert(), BMS_DIFFERENT, BMS_EQUAL, BMS_SUBSET1, BMS_SUBSET2, bms_subset_compare(), RelOptInfo::cheapest_parameterized_paths, RelOptInfo::cheapest_startup_path, RelOptInfo::cheapest_total_path, RelOptInfo::cheapest_unique_path, cmp(), compare_path_costs(), compare_pathkeys(), elog, ERROR, IsA, lappend(), lcons(), lfirst, NIL, PATH_REQ_OUTER, Path::pathkeys, PATHKEYS_BETTER2, RelOptInfo::pathlist, STARTUP_COST, and TOTAL_COST.

Referenced by apply_scanjoin_target_to_paths(), create_distinct_paths(), create_grouping_paths(), create_ordinary_grouping_paths(), create_partial_distinct_paths(), create_partitionwise_grouping_paths(), create_window_paths(), generate_partitionwise_join_paths(), mark_dummy_rel(), merge_clump(), postprocess_setop_rel(), query_planner(), set_dummy_rel_pathlist(), set_rel_pathlist(), standard_join_search(), and subquery_planner().

setup_simple_rel_arrays()

void setup_simple_rel_arrays

(

PlannerInfo *

root

)

Definition at line 94 of file relnode.c.

{
    int         size;
    Index       rti;
    ListCell   *lc;
 
    /* Arrays are accessed using RT indexes (1..N) */
    size = list_length(root->parse->rtable) + 1;
    root->simple_rel_array_size = size;
 
    /*
     * simple_rel_array is initialized to all NULLs, since no RelOptInfos
     * exist yet.  It'll be filled by later calls to build_simple_rel().
     */
    root->simple_rel_array = (RelOptInfo **)
        palloc0(size * sizeof(RelOptInfo *));
 
    /* simple_rte_array is an array equivalent of the rtable list */
    root->simple_rte_array = (RangeTblEntry **)
        palloc0(size * sizeof(RangeTblEntry *));
    rti = 1;
    foreach(lc, root->parse->rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
 
        root->simple_rte_array[rti++] = rte;
    }
 
    /* append_rel_array is not needed if there are no AppendRelInfos */
    if (root->append_rel_list == NIL)
    {
        root->append_rel_array = NULL;
        return;
    }
 
    root->append_rel_array = (AppendRelInfo **)
        palloc0(size * sizeof(AppendRelInfo *));
 
    /*
     * append_rel_array is filled with any already-existing AppendRelInfos,
     * which currently could only come from UNION ALL flattening.  We might
     * add more later during inheritance expansion, but it's the
     * responsibility of the expansion code to update the array properly.
     */
    foreach(lc, root->append_rel_list)
    {
        AppendRelInfo *appinfo = lfirst_node(AppendRelInfo, lc);
        int         child_relid = appinfo->child_relid;
 
        /* Sanity check */
        Assert(child_relid < size);
 
        if (root->append_rel_array[child_relid])
            elog(ERROR, "child relation already exists");
 
        root->append_rel_array[child_relid] = appinfo;
    }
}

References Assert(), AppendRelInfo::child_relid, elog, ERROR, lfirst, lfirst_node, list_length(), NIL, palloc0(), and root.

Referenced by plan_cluster_use_sort(), plan_create_index_workers(), plan_set_operations(), and query_planner().