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, 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, 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, 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, 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, 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, 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)
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, WindowClause *winclause, List *qual, bool topwindow)
SetOpPath *	create_setop_path (PlannerInfo *root, RelOptInfo *rel, Path *subpath, SetOpCmd cmd, SetOpStrategy strategy, List *distinctList, AttrNumber flagColIdx, int firstFlag, 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, 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)
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_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)

Function Documentation

add_partial_path()

void add_partial_path	(	RelOptInfo *	parent_rel,
		Path *	new_path
	)

Definition at line 749 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 (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, 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, and Path::total_cost.

Referenced by add_paths_to_append_rel(), build_index_paths(), create_partial_bitmap_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), create_plain_partial_paths(), grouping_planner(), recurse_set_operations(), 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,
		Cost	total_cost,
		List *	pathkeys
	)

Definition at line 867 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, 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 422 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 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 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, 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(), 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(), recurse_set_operations(), 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,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Relids	required_outer
	)

Definition at line 644 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;
 
        /*
         * 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.
         */
        if (total_cost > old_path->total_cost * STD_FUZZ_FACTOR)
        {
            /* 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;
                    }
                }
            }
        }
        else
        {
            /*
             * Since the pathlist is sorted by total_cost, we can stop looking
             * once we reach a path with a total_cost larger than the new
             * path's.
             */
            break;
        }
    }
 
    return true;
}

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

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 3834 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 2752 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, 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
	)

Definition at line 858 of file relnode.c.

{
    RelOptInfo *joinrel = makeNode(RelOptInfo);
    AppendRelInfo **appinfos;
    int         nappinfos;
 
    /* 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);
 
    /*
     * Find the AppendRelInfo structures for the child baserels.  We'll need
     * these for computing the child join's relid set, and later for mapping
     * Vars to the child rel.
     */
    appinfos = find_appinfos_by_relids(root,
                                       bms_union(outer_rel->relids,
                                                 inner_rel->relids),
                                       &nappinfos);
 
    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->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);
 
    pfree(appinfos);
 
    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(), bms_union(), 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_appinfos_by_relids(), 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::nparts, RelOptInfo::nulling_relids, RelOptInfo::pages, RelOptInfo::partbounds_merged, RelOptInfo::partial_pathlist, RelOptInfo::partition_qual, RelOptInfo::pathlist, QualCost::per_tuple, pfree(), RelOptInfo::ppilist, RelOptInfo::relid, RelOptInfo::relids, RELOPT_OTHER_JOINREL, RelOptInfo::reloptkind, RelOptInfo::reltarget, 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, PlannerInfo::tuple_fraction, 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 643 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->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(), PlannerInfo::join_cur_level, 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::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, 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, PlannerInfo::tuple_fraction, 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 191 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->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;
    }
 
    /*
     * Copy the parent's quals to the child, with appropriate substitution of
     * variables.  If any constant false or NULL clauses turn up, we can 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))
        {
            /*
             * Some restriction clause reduced to constant FALSE or NULL after
             * substitution, so this child need not be scanned.
             */
            mark_dummy_rel(rel);
        }
    }
 
    /* Save the finished struct in the query's simple_rel_array */
    root->simple_rel_array[relid] = 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, Alias::colnames, 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(), RangeTblEntry::eref, 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::nparts, RelOptInfo::nulling_relids, RelOptInfo::pages, palloc0(), PlannerInfo::parse, RelOptInfo::partbounds_merged, RelOptInfo::partial_pathlist, RelOptInfo::partition_qual, RelOptInfo::pathlist, QualCost::per_tuple, RelOptInfo::ppilist, RelOptInfo::rel_parallel_workers, RangeTblEntry::relid, RelOptInfo::relid, RelOptInfo::relids, RELOPT_BASEREL, RELOPT_OTHER_MEMBER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, 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, PlannerInfo::tuple_fraction, 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 2366 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 2393 of file pathnode.c.

{
    Relids      outer_paramrels = PATH_REQ_OUTER(outer_path);
    Relids      inner_paramrels = PATH_REQ_OUTER(inner_path);
    Relids      required_outer;
 
    /* neither path can require rels from the other */
    Assert(!bms_overlap(outer_paramrels, inner_path->parent->relids));
    Assert(!bms_overlap(inner_paramrels, outer_path->parent->relids));
    /* 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(), and PATH_REQ_OUTER.

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 117 of file pathnode.c.

{
    Cost        cost1,
                cost2;
 
    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::startup_cost, TOTAL_COST, and Path::total_cost.

Referenced by choose_hashed_setop(), 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 71 of file pathnode.c.

{
    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 STARTUP_COST, Path::startup_cost, and Path::total_cost.

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 3114 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->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, PlannerInfo::num_groupby_pathkeys, AggPath::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, AggPath::path, Path::pathkeys, Path::pathtype, QualCost::per_tuple, AggPath::qual, 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 make_union_unique().

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 1242 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 PlannerInfo::all_query_rels, 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, PlannerInfo::limit_tuples, 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, Path::rows, Path::startup_cost, subpath(), AppendPath::subpaths, and Path::total_cost.

Referenced by add_paths_to_append_rel(), create_degenerate_grouping_paths(), generate_nonunion_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 1077 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, and RelOptInfo::reltarget.

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 1044 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, and RelOptInfo::reltarget.

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 1129 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, and RelOptInfo::reltarget.

Referenced by generate_bitmap_or_paths().

create_ctescan_path()

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

Definition at line 2116 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 = NIL;   /* XXX for now, result is always unordered */
 
    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, and RelOptInfo::reltarget.

Referenced by set_cte_pathlist().

create_foreign_join_path()

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

Definition at line 2272 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.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, 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,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Path *	fdw_outerpath,
		List *	fdw_restrictinfo,
		List *	fdw_private
	)

Definition at line 2324 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.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, 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,
		Cost	startup_cost,
		Cost	total_cost,
		List *	pathkeys,
		Relids	required_outer,
		Path *	fdw_outerpath,
		List *	fdw_restrictinfo,
		List *	fdw_private
	)

Definition at line 2226 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.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, 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, 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 2038 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, and RelOptInfo::reltarget.

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 1873 of file pathnode.c.

{
    GatherMergePath *pathnode = makeNode(GatherMergePath);
    Cost        input_startup_cost = 0;
    Cost        input_total_cost = 0;
 
    Assert(subpath->parallel_safe);
    Assert(pathkeys);
 
    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;
    pathnode->path.rows += subpath->rows;
 
    if (pathkeys_contained_in(pathkeys, subpath->pathkeys))
    {
        /* Subpath is adequately ordered, we won't need to sort it */
        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->total_cost,
                  subpath->rows,
                  subpath->pathtarget->width,
                  0.0,
                  work_mem,
                  -1);
        input_startup_cost += sort_path.startup_cost;
        input_total_cost += sort_path.total_cost;
    }
 
    cost_gather_merge(pathnode, root, rel, pathnode->path.param_info,
                      input_startup_cost, input_total_cost, rows);
 
    return pathnode;
}

References Assert(), cost_gather_merge(), cost_sort(), get_baserel_parampathinfo(), makeNode, GatherMergePath::num_workers, Path::parallel_aware, GatherMergePath::path, Path::pathkeys, pathkeys_contained_in(), Path::pathtype, RelOptInfo::reltarget, Path::rows, Path::startup_cost, subpath(), GatherMergePath::subpath, Path::total_cost, and work_mem.

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 1964 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, 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 3003 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->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, 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 1516 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, 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 3196 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->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,
                         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,
                          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.startup_cost,
                         sort_path.total_cost,
                         sort_path.rows,
                         subpath->pathtarget->width);
            }
 
            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(), PlannerInfo::group_pathkeys, 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, 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 2578 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, 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 2910 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->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, sort(), subpath(), SortPath::subpath, and work_mem.

Referenced by add_paths_to_grouping_rel(), create_final_distinct_paths(), create_one_window_path(), create_ordered_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), gather_grouping_paths(), and generate_useful_gather_paths().

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 995 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, and RelOptInfo::reltarget.

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 3779 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.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, 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(), and grouping_planner().

create_lockrows_path()

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

Definition at line 3618 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.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost +
        cpu_tuple_cost * subpath->rows;
 
    return pathnode;
}

References cpu_tuple_cost, 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 1564 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->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 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 1596 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 = 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;
 
    /*
     * 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, RelOptInfo::consider_parallel, cpu_tuple_cost, 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 1413 of file pathnode.c.

{
    MergeAppendPath *pathnode = makeNode(MergeAppendPath);
    Cost        input_startup_cost;
    Cost        input_total_cost;
    ListCell   *l;
 
    pathnode->path.pathtype = T_MergeAppend;
    pathnode->path.parent = rel;
    pathnode->path.pathtarget = rel->reltarget;
    pathnode->path.param_info = get_appendrel_parampathinfo(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->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_startup_cost = 0;
    input_total_cost = 0;
    foreach(l, subpaths)
    {
        Path       *subpath = (Path *) lfirst(l);
 
        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_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->total_cost,
                      subpath->parent->tuples,
                      subpath->pathtarget->width,
                      0.0,
                      work_mem,
                      pathnode->limit_tuples);
            input_startup_cost += sort_path.startup_cost;
            input_total_cost += sort_path.total_cost;
        }
 
        /* All child paths must have same parameterization */
        Assert(bms_equal(PATH_REQ_OUTER(subpath), required_outer));
    }
 
    /*
     * 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.startup_cost = input_startup_cost;
        pathnode->path.total_cost = input_total_cost;
    }
    else
        cost_merge_append(&pathnode->path, root,
                          pathkeys, list_length(subpaths),
                          input_startup_cost, input_total_cost,
                          pathnode->path.rows);
 
    return pathnode;
}

References PlannerInfo::all_query_rels, Assert(), bms_equal(), RelOptInfo::consider_parallel, cost_merge_append(), cost_sort(), get_appendrel_parampathinfo(), lfirst, PlannerInfo::limit_tuples, 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, Path::rows, Path::startup_cost, subpath(), MergeAppendPath::subpaths, Path::total_cost, and work_mem.

Referenced by generate_orderedappend_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
	)

Definition at line 2512 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->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, JoinPath::outerjoinpath, MergePath::outersortkeys, Path::parallel_safe, Path::parallel_workers, MergePath::path_mergeclauses, RelOptInfo::reltarget, 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 3356 of file pathnode.c.

{
    MinMaxAggPath *pathnode = makeNode(MinMaxAggPath);
    Cost        initplan_cost;
    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_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.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, 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, 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,
		int	epqParam
	)

Definition at line 3680 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.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;
 
    return pathnode;
}

References Assert(), ModifyTablePath::canSetTag, CMD_MERGE, CMD_UPDATE, ModifyTablePath::epqParam, list_length(), makeNode, ModifyTablePath::mergeActionLists, 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 2141 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, and RelOptInfo::reltarget.

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 2426 of file pathnode.c.

{
    NestPath   *pathnode = makeNode(NestPath);
    Relids      inner_req_outer = PATH_REQ_OUTER(inner_path);
 
    /*
     * 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, outer_path->parent->relids))
    {
        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, 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 2644 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.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.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, 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, 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 3573 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 2167 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, and RelOptInfo::reltarget.

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 954 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, and RelOptInfo::reltarget.

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 929 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, and RelOptInfo::reltarget.

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 2841 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.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, 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, 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 *	subpath,
		SetOpCmd	cmd,
		SetOpStrategy	strategy,
		List *	distinctList,
		AttrNumber	flagColIdx,
		int	firstFlag,
		double	numGroups,
		double	outputRows
	)

Definition at line 3511 of file pathnode.c.

{
    SetOpPath  *pathnode = makeNode(SetOpPath);
 
    pathnode->path.pathtype = T_SetOp;
    pathnode->path.parent = rel;
    /* SetOp 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;
    /* SetOp preserves the input sort order if in sort mode */
    pathnode->path.pathkeys =
        (strategy == SETOP_SORTED) ? subpath->pathkeys : NIL;
 
    pathnode->subpath = subpath;
    pathnode->cmd = cmd;
    pathnode->strategy = strategy;
    pathnode->distinctList = distinctList;
    pathnode->flagColIdx = flagColIdx;
    pathnode->firstFlag = firstFlag;
    pathnode->numGroups = numGroups;
 
    /*
     * Charge one cpu_operator_cost per comparison per input tuple. We assume
     * all columns get compared at most of the tuples.
     */
    pathnode->path.startup_cost = subpath->startup_cost;
    pathnode->path.total_cost = subpath->total_cost +
        cpu_operator_cost * subpath->rows * list_length(distinctList);
    pathnode->path.rows = outputRows;
 
    return pathnode;
}

References SetOpPath::cmd, RelOptInfo::consider_parallel, cpu_operator_cost, SetOpPath::distinctList, SetOpPath::firstFlag, SetOpPath::flagColIdx, list_length(), makeNode, NIL, SetOpPath::numGroups, Path::parallel_aware, Path::parallel_safe, Path::parallel_workers, SetOpPath::path, Path::pathkeys, Path::pathtype, Path::rows, SETOP_SORTED, Path::startup_cost, SetOpPath::strategy, subpath(), SetOpPath::subpath, 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 2959 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->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, subpath(), SortPath::subpath, and work_mem.

Referenced by add_paths_to_grouping_rel(), add_paths_with_pathkeys_for_rel(), create_final_distinct_paths(), create_one_window_path(), create_ordered_paths(), create_partial_distinct_paths(), create_partial_grouping_paths(), gather_grouping_paths(), generate_nonunion_paths(), generate_useful_gather_paths(), and make_union_unique().

create_subqueryscan_path()

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

Definition at line 2008 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, subpath(), and SubqueryScanPath::subpath.

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

create_tablefuncscan_path()

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

Definition at line 2064 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, and RelOptInfo::reltarget.

Referenced by set_tablefunc_pathlist().

create_tidrangescan_path()

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

Definition at line 1210 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, 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 1181 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, 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 1652 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;
    pathnode->in_operators = sjinfo->semi_operators;
    pathnode->uniq_exprs = 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.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.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->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->startup_cost,
                     subpath->total_cost,
                     rel->rows,
                     subpath->pathtarget->width);
    }
 
    if (sjinfo->semi_can_btree && sjinfo->semi_can_hash)
    {
        if (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.startup_cost = agg_path.startup_cost;
        pathnode->path.total_cost = agg_path.total_cost;
    }
    else
    {
        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, cost_agg(), cost_sort(), cpu_operator_cost, 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, 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 3062 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.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, 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 make_union_unique().

create_valuesscan_path()

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

Definition at line 2090 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, and RelOptInfo::reltarget.

Referenced by set_values_pathlist().

create_windowagg_path()

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

Definition at line 3443 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 =