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

Include dependency graph for cost.h:

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

Macros
#define	DEFAULT_SEQ_PAGE_COST 1.0

#define	DEFAULT_RANDOM_PAGE_COST 4.0

#define	DEFAULT_CPU_TUPLE_COST 0.01

#define	DEFAULT_CPU_INDEX_TUPLE_COST 0.005

#define	DEFAULT_CPU_OPERATOR_COST 0.0025

#define	DEFAULT_PARALLEL_TUPLE_COST 0.1

#define	DEFAULT_PARALLEL_SETUP_COST 1000.0

#define	DEFAULT_RECURSIVE_WORKTABLE_FACTOR 10.0

#define	DEFAULT_EFFECTIVE_CACHE_SIZE 524288 /* measured in pages */

Enumerations
enum	ConstraintExclusionType { CONSTRAINT_EXCLUSION_OFF , CONSTRAINT_EXCLUSION_ON , CONSTRAINT_EXCLUSION_PARTITION }

Functions
double	index_pages_fetched (double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root)

void	cost_seqscan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_samplescan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_index (IndexPath path, PlannerInfo root, double loop_count, bool partial_path)

void	cost_bitmap_heap_scan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info, Path *bitmapqual, double loop_count)

void	cost_bitmap_and_node (BitmapAndPath path, PlannerInfo root)

void	cost_bitmap_or_node (BitmapOrPath path, PlannerInfo root)

void	cost_bitmap_tree_node (Path path, Cost cost, Selectivity *selec)

void	cost_tidscan (Path path, PlannerInfo root, RelOptInfo baserel, List tidquals, ParamPathInfo *param_info)

void	cost_tidrangescan (Path path, PlannerInfo root, RelOptInfo baserel, List tidrangequals, ParamPathInfo *param_info)

void	cost_subqueryscan (SubqueryScanPath path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info, bool trivial_pathtarget)

void	cost_functionscan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_valuesscan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_tablefuncscan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_ctescan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_namedtuplestorescan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_resultscan (Path path, PlannerInfo root, RelOptInfo baserel, ParamPathInfo param_info)

void	cost_recursive_union (Path runion, Path nrterm, Path *rterm)

void	cost_sort (Path path, PlannerInfo root, List *pathkeys, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)

void	cost_incremental_sort (Path path, PlannerInfo root, List *pathkeys, int presorted_keys, Cost input_startup_cost, Cost input_total_cost, double input_tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)

void	cost_append (AppendPath *apath)

void	cost_merge_append (Path path, PlannerInfo root, List *pathkeys, int n_streams, Cost input_startup_cost, Cost input_total_cost, double tuples)

void	cost_material (Path *path, Cost input_startup_cost, Cost input_total_cost, double tuples, int width)

void	cost_agg (Path path, PlannerInfo root, AggStrategy aggstrategy, const AggClauseCosts aggcosts, int numGroupCols, double numGroups, List quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples, double input_width)

void	cost_windowagg (Path path, PlannerInfo root, List windowFuncs, WindowClause winclause, Cost input_startup_cost, Cost input_total_cost, double input_tuples)

void	cost_group (Path path, PlannerInfo root, int numGroupCols, double numGroups, List *quals, Cost input_startup_cost, Cost input_total_cost, double input_tuples)

void	initial_cost_nestloop (PlannerInfo root, JoinCostWorkspace workspace, JoinType jointype, Path outer_path, Path inner_path, JoinPathExtraData *extra)

void	final_cost_nestloop (PlannerInfo root, NestPath path, JoinCostWorkspace workspace, JoinPathExtraData extra)

void	initial_cost_mergejoin (PlannerInfo root, JoinCostWorkspace workspace, JoinType jointype, List mergeclauses, Path outer_path, Path inner_path, List outersortkeys, List innersortkeys, JoinPathExtraData extra)

void	final_cost_mergejoin (PlannerInfo root, MergePath path, JoinCostWorkspace workspace, JoinPathExtraData extra)

void	initial_cost_hashjoin (PlannerInfo root, JoinCostWorkspace workspace, JoinType jointype, List hashclauses, Path outer_path, Path inner_path, JoinPathExtraData extra, bool parallel_hash)

void	final_cost_hashjoin (PlannerInfo root, HashPath path, JoinCostWorkspace workspace, JoinPathExtraData extra)

void	cost_gather (GatherPath path, PlannerInfo root, RelOptInfo rel, ParamPathInfo param_info, double *rows)

void	cost_gather_merge (GatherMergePath path, PlannerInfo root, RelOptInfo rel, ParamPathInfo param_info, Cost input_startup_cost, Cost input_total_cost, double *rows)

void	cost_subplan (PlannerInfo root, SubPlan subplan, Plan *plan)

void	cost_qual_eval (QualCost cost, List quals, PlannerInfo *root)

void	cost_qual_eval_node (QualCost cost, Node qual, PlannerInfo *root)

void	compute_semi_anti_join_factors (PlannerInfo root, RelOptInfo joinrel, RelOptInfo outerrel, RelOptInfo innerrel, JoinType jointype, SpecialJoinInfo sjinfo, List restrictlist, SemiAntiJoinFactors *semifactors)

void	set_baserel_size_estimates (PlannerInfo root, RelOptInfo rel)

double	get_parameterized_baserel_size (PlannerInfo root, RelOptInfo rel, List *param_clauses)

double	get_parameterized_joinrel_size (PlannerInfo root, RelOptInfo rel, Path outer_path, Path inner_path, SpecialJoinInfo sjinfo, List restrict_clauses)

void	set_joinrel_size_estimates (PlannerInfo root, RelOptInfo rel, RelOptInfo outer_rel, RelOptInfo inner_rel, SpecialJoinInfo sjinfo, List restrictlist)

void	set_subquery_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_function_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_values_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_cte_size_estimates (PlannerInfo root, RelOptInfo rel, double cte_rows)

void	set_tablefunc_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_namedtuplestore_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_result_size_estimates (PlannerInfo root, RelOptInfo rel)

void	set_foreign_size_estimates (PlannerInfo root, RelOptInfo rel)

PathTarget *	set_pathtarget_cost_width (PlannerInfo root, PathTarget target)

double	compute_bitmap_pages (PlannerInfo root, RelOptInfo baserel, Path bitmapqual, double loop_count, Cost cost_p, double *tuples_p)

double	compute_gather_rows (Path *path)

Variables
PGDLLIMPORT Cost	disable_cost

PGDLLIMPORT int	max_parallel_workers_per_gather

PGDLLIMPORT bool	enable_seqscan

PGDLLIMPORT bool	enable_indexscan

PGDLLIMPORT bool	enable_indexonlyscan

PGDLLIMPORT bool	enable_bitmapscan

PGDLLIMPORT bool	enable_tidscan

PGDLLIMPORT bool	enable_sort

PGDLLIMPORT bool	enable_incremental_sort

PGDLLIMPORT bool	enable_hashagg

PGDLLIMPORT bool	enable_nestloop

PGDLLIMPORT bool	enable_material

PGDLLIMPORT bool	enable_memoize

PGDLLIMPORT bool	enable_mergejoin

PGDLLIMPORT bool	enable_hashjoin

PGDLLIMPORT bool	enable_gathermerge

PGDLLIMPORT bool	enable_partitionwise_join

PGDLLIMPORT bool	enable_partitionwise_aggregate

PGDLLIMPORT bool	enable_parallel_append

PGDLLIMPORT bool	enable_parallel_hash

PGDLLIMPORT bool	enable_partition_pruning

PGDLLIMPORT bool	enable_presorted_aggregate

PGDLLIMPORT bool	enable_async_append

PGDLLIMPORT int	constraint_exclusion

Macro Definition Documentation

◆ DEFAULT_CPU_INDEX_TUPLE_COST

#define DEFAULT_CPU_INDEX_TUPLE_COST 0.005

Definition at line 27 of file cost.h.

◆ DEFAULT_CPU_OPERATOR_COST

#define DEFAULT_CPU_OPERATOR_COST 0.0025

Definition at line 28 of file cost.h.

◆ DEFAULT_CPU_TUPLE_COST

#define DEFAULT_CPU_TUPLE_COST 0.01

Definition at line 26 of file cost.h.

◆ DEFAULT_EFFECTIVE_CACHE_SIZE

#define DEFAULT_EFFECTIVE_CACHE_SIZE 524288 /* measured in pages */

Definition at line 34 of file cost.h.

◆ DEFAULT_PARALLEL_SETUP_COST

#define DEFAULT_PARALLEL_SETUP_COST 1000.0

Definition at line 30 of file cost.h.

◆ DEFAULT_PARALLEL_TUPLE_COST

#define DEFAULT_PARALLEL_TUPLE_COST 0.1

Definition at line 29 of file cost.h.

◆ DEFAULT_RANDOM_PAGE_COST

#define DEFAULT_RANDOM_PAGE_COST 4.0

Definition at line 25 of file cost.h.

◆ DEFAULT_RECURSIVE_WORKTABLE_FACTOR

#define DEFAULT_RECURSIVE_WORKTABLE_FACTOR 10.0

Definition at line 33 of file cost.h.

◆ DEFAULT_SEQ_PAGE_COST

#define DEFAULT_SEQ_PAGE_COST 1.0

Definition at line 24 of file cost.h.

Enumeration Type Documentation

◆ ConstraintExclusionType

enum ConstraintExclusionType

Enumerator
CONSTRAINT_EXCLUSION_OFF
CONSTRAINT_EXCLUSION_ON
CONSTRAINT_EXCLUSION_PARTITION

Definition at line 36 of file cost.h.

 {
     CONSTRAINT_EXCLUSION_OFF,   /* do not use c_e */
     CONSTRAINT_EXCLUSION_ON,    /* apply c_e to all rels */
     CONSTRAINT_EXCLUSION_PARTITION, /* apply c_e to otherrels only */
 }           ConstraintExclusionType;

Function Documentation

◆ compute_bitmap_pages()

double compute_bitmap_pages	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		Path *	bitmapqual,
		double	loop_count,
		Cost *	cost_p,
		double *	tuples_p
	)

Definition at line 6377 of file costsize.c.

 {
     Cost        indexTotalCost;
     Selectivity indexSelectivity;
     double      T;
     double      pages_fetched;
     double      tuples_fetched;
     double      heap_pages;
     long        maxentries;
  
     /*
      * Fetch total cost of obtaining the bitmap, as well as its total
      * selectivity.
      */
     cost_bitmap_tree_node(bitmapqual, &indexTotalCost, &indexSelectivity);
  
     /*
      * Estimate number of main-table pages fetched.
      */
     tuples_fetched = clamp_row_est(indexSelectivity * baserel->tuples);
  
     T = (baserel->pages > 1) ? (double) baserel->pages : 1.0;
  
     /*
      * For a single scan, the number of heap pages that need to be fetched is
      * the same as the Mackert and Lohman formula for the case T <= b (ie, no
      * re-reads needed).
      */
     pages_fetched = (2.0 * T * tuples_fetched) / (2.0 * T + tuples_fetched);
  
     /*
      * Calculate the number of pages fetched from the heap.  Then based on
      * current work_mem estimate get the estimated maxentries in the bitmap.
      * (Note that we always do this calculation based on the number of pages
      * that would be fetched in a single iteration, even if loop_count > 1.
      * That's correct, because only that number of entries will be stored in
      * the bitmap at one time.)
      */
     heap_pages = Min(pages_fetched, baserel->pages);
     maxentries = tbm_calculate_entries(work_mem * 1024L);
  
     if (loop_count > 1)
     {
         /*
          * For repeated bitmap scans, scale up the number of tuples fetched in
          * the Mackert and Lohman formula by the number of scans, so that we
          * estimate the number of pages fetched by all the scans. Then
          * pro-rate for one scan.
          */
         pages_fetched = index_pages_fetched(tuples_fetched * loop_count,
                                             baserel->pages,
                                             get_indexpath_pages(bitmapqual),
                                             root);
         pages_fetched /= loop_count;
     }
  
     if (pages_fetched >= T)
         pages_fetched = T;
     else
         pages_fetched = ceil(pages_fetched);
  
     if (maxentries < heap_pages)
     {
         double      exact_pages;
         double      lossy_pages;
  
         /*
          * Crude approximation of the number of lossy pages.  Because of the
          * way tbm_lossify() is coded, the number of lossy pages increases
          * very sharply as soon as we run short of memory; this formula has
          * that property and seems to perform adequately in testing, but it's
          * possible we could do better somehow.
          */
         lossy_pages = Max(0, heap_pages - maxentries / 2);
         exact_pages = heap_pages - lossy_pages;
  
         /*
          * If there are lossy pages then recompute the number of tuples
          * processed by the bitmap heap node.  We assume here that the chance
          * of a given tuple coming from an exact page is the same as the
          * chance that a given page is exact.  This might not be true, but
          * it's not clear how we can do any better.
          */
         if (lossy_pages > 0)
             tuples_fetched =
                 clamp_row_est(indexSelectivity *
                               (exact_pages / heap_pages) * baserel->tuples +
                               (lossy_pages / heap_pages) * baserel->tuples);
     }
  
     if (cost_p)
         *cost_p = indexTotalCost;
     if (tuples_p)
         *tuples_p = tuples_fetched;
  
     return pages_fetched;
 }

References clamp_row_est(), cost_bitmap_tree_node(), get_indexpath_pages(), index_pages_fetched(), Max, Min, RelOptInfo::pages, root, T, tbm_calculate_entries(), RelOptInfo::tuples, and work_mem.

Referenced by cost_bitmap_heap_scan(), and create_partial_bitmap_paths().

◆ compute_gather_rows()

double compute_gather_rows ( Path * path )

Definition at line 6488 of file costsize.c.

 {
     Assert(path->parallel_workers > 0);
  
     return clamp_row_est(path->rows * get_parallel_divisor(path));
 }

References Assert, clamp_row_est(), get_parallel_divisor(), Path::parallel_workers, and Path::rows.

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

◆ compute_semi_anti_join_factors()

void compute_semi_anti_join_factors	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		RelOptInfo *	outerrel,
		RelOptInfo *	innerrel,
		JoinType	jointype,
		SpecialJoinInfo *	sjinfo,
		List *	restrictlist,
		SemiAntiJoinFactors *	semifactors
	)

Definition at line 4978 of file costsize.c.

 {
     Selectivity jselec;
     Selectivity nselec;
     Selectivity avgmatch;
     SpecialJoinInfo norm_sjinfo;
     List       *joinquals;
     ListCell   *l;
  
     /*
      * In an ANTI join, we must ignore clauses that are "pushed down", since
      * those won't affect the match logic.  In a SEMI join, we do not
      * distinguish joinquals from "pushed down" quals, so just use the whole
      * restrictinfo list.  For other outer join types, we should consider only
      * non-pushed-down quals, so that this devolves to an IS_OUTER_JOIN check.
      */
     if (IS_OUTER_JOIN(jointype))
     {
         joinquals = NIL;
         foreach(l, restrictlist)
         {
             RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
  
             if (!RINFO_IS_PUSHED_DOWN(rinfo, joinrel->relids))
                 joinquals = lappend(joinquals, rinfo);
         }
     }
     else
         joinquals = restrictlist;
  
     /*
      * Get the JOIN_SEMI or JOIN_ANTI selectivity of the join clauses.
      */
     jselec = clauselist_selectivity(root,
                                     joinquals,
                                     0,
                                     (jointype == JOIN_ANTI) ? JOIN_ANTI : JOIN_SEMI,
                                     sjinfo);
  
     /*
      * Also get the normal inner-join selectivity of the join clauses.
      */
     init_dummy_sjinfo(&norm_sjinfo, outerrel->relids, innerrel->relids);
  
     nselec = clauselist_selectivity(root,
                                     joinquals,
                                     0,
                                     JOIN_INNER,
                                     &norm_sjinfo);
  
     /* Avoid leaking a lot of ListCells */
     if (IS_OUTER_JOIN(jointype))
         list_free(joinquals);
  
     /*
      * jselec can be interpreted as the fraction of outer-rel rows that have
      * any matches (this is true for both SEMI and ANTI cases).  And nselec is
      * the fraction of the Cartesian product that matches.  So, the average
      * number of matches for each outer-rel row that has at least one match is
      * nselec * inner_rows / jselec.
      *
      * Note: it is correct to use the inner rel's "rows" count here, even
      * though we might later be considering a parameterized inner path with
      * fewer rows.  This is because we have included all the join clauses in
      * the selectivity estimate.
      */
     if (jselec > 0)             /* protect against zero divide */
     {
         avgmatch = nselec * innerrel->rows / jselec;
         /* Clamp to sane range */
         avgmatch = Max(1.0, avgmatch);
     }
     else
         avgmatch = 1.0;
  
     semifactors->outer_match_frac = jselec;
     semifactors->match_count = avgmatch;
 }

References clauselist_selectivity(), init_dummy_sjinfo(), IS_OUTER_JOIN, JOIN_ANTI, JOIN_INNER, JOIN_SEMI, lappend(), lfirst_node, list_free(), SemiAntiJoinFactors::match_count, Max, NIL, SemiAntiJoinFactors::outer_match_frac, RelOptInfo::relids, RINFO_IS_PUSHED_DOWN, root, and RelOptInfo::rows.

Referenced by add_paths_to_joinrel().

◆ cost_agg()

void cost_agg	(	Path *	path,
		PlannerInfo *	root,
		AggStrategy	aggstrategy,
		const AggClauseCosts *	aggcosts,
		int	numGroupCols,
		double	numGroups,
		List *	quals,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	input_tuples,
		double	input_width
	)

Definition at line 2629 of file costsize.c.

 {
     double      output_tuples;
     Cost        startup_cost;
     Cost        total_cost;
     AggClauseCosts dummy_aggcosts;
  
     /* Use all-zero per-aggregate costs if NULL is passed */
     if (aggcosts == NULL)
     {
         Assert(aggstrategy == AGG_HASHED);
         MemSet(&dummy_aggcosts, 0, sizeof(AggClauseCosts));
         aggcosts = &dummy_aggcosts;
     }
  
     /*
      * The transCost.per_tuple component of aggcosts should be charged once
      * per input tuple, corresponding to the costs of evaluating the aggregate
      * transfns and their input expressions. The finalCost.per_tuple component
      * is charged once per output tuple, corresponding to the costs of
      * evaluating the finalfns.  Startup costs are of course charged but once.
      *
      * If we are grouping, we charge an additional cpu_operator_cost per
      * grouping column per input tuple for grouping comparisons.
      *
      * We will produce a single output tuple if not grouping, and a tuple per
      * group otherwise.  We charge cpu_tuple_cost for each output tuple.
      *
      * Note: in this cost model, AGG_SORTED and AGG_HASHED have exactly the
      * same total CPU cost, but AGG_SORTED has lower startup cost.  If the
      * input path is already sorted appropriately, AGG_SORTED should be
      * preferred (since it has no risk of memory overflow).  This will happen
      * as long as the computed total costs are indeed exactly equal --- but if
      * there's roundoff error we might do the wrong thing.  So be sure that
      * the computations below form the same intermediate values in the same
      * order.
      */
     if (aggstrategy == AGG_PLAIN)
     {
         startup_cost = input_total_cost;
         startup_cost += aggcosts->transCost.startup;
         startup_cost += aggcosts->transCost.per_tuple * input_tuples;
         startup_cost += aggcosts->finalCost.startup;
         startup_cost += aggcosts->finalCost.per_tuple;
         /* we aren't grouping */
         total_cost = startup_cost + cpu_tuple_cost;
         output_tuples = 1;
     }
     else if (aggstrategy == AGG_SORTED || aggstrategy == AGG_MIXED)
     {
         /* Here we are able to deliver output on-the-fly */
         startup_cost = input_startup_cost;
         total_cost = input_total_cost;
         if (aggstrategy == AGG_MIXED && !enable_hashagg)
         {
             startup_cost += disable_cost;
             total_cost += disable_cost;
         }
         /* calcs phrased this way to match HASHED case, see note above */
         total_cost += aggcosts->transCost.startup;
         total_cost += aggcosts->transCost.per_tuple * input_tuples;
         total_cost += (cpu_operator_cost * numGroupCols) * input_tuples;
         total_cost += aggcosts->finalCost.startup;
         total_cost += aggcosts->finalCost.per_tuple * numGroups;
         total_cost += cpu_tuple_cost * numGroups;
         output_tuples = numGroups;
     }
     else
     {
         /* must be AGG_HASHED */
         startup_cost = input_total_cost;
         if (!enable_hashagg)
             startup_cost += disable_cost;
         startup_cost += aggcosts->transCost.startup;
         startup_cost += aggcosts->transCost.per_tuple * input_tuples;
         /* cost of computing hash value */
         startup_cost += (cpu_operator_cost * numGroupCols) * input_tuples;
         startup_cost += aggcosts->finalCost.startup;
  
         total_cost = startup_cost;
         total_cost += aggcosts->finalCost.per_tuple * numGroups;
         /* cost of retrieving from hash table */
         total_cost += cpu_tuple_cost * numGroups;
         output_tuples = numGroups;
     }
  
     /*
      * Add the disk costs of hash aggregation that spills to disk.
      *
      * Groups that go into the hash table stay in memory until finalized, so
      * spilling and reprocessing tuples doesn't incur additional invocations
      * of transCost or finalCost. Furthermore, the computed hash value is
      * stored with the spilled tuples, so we don't incur extra invocations of
      * the hash function.
      *
      * Hash Agg begins returning tuples after the first batch is complete.
      * Accrue writes (spilled tuples) to startup_cost and to total_cost;
      * accrue reads only to total_cost.
      */
     if (aggstrategy == AGG_HASHED || aggstrategy == AGG_MIXED)
     {
         double      pages;
         double      pages_written = 0.0;
         double      pages_read = 0.0;
         double      spill_cost;
         double      hashentrysize;
         double      nbatches;
         Size        mem_limit;
         uint64      ngroups_limit;
         int         num_partitions;
         int         depth;
  
         /*
          * Estimate number of batches based on the computed limits. If less
          * than or equal to one, all groups are expected to fit in memory;
          * otherwise we expect to spill.
          */
         hashentrysize = hash_agg_entry_size(list_length(root->aggtransinfos),
                                             input_width,
                                             aggcosts->transitionSpace);
         hash_agg_set_limits(hashentrysize, numGroups, 0, &mem_limit,
                             &ngroups_limit, &num_partitions);
  
         nbatches = Max((numGroups * hashentrysize) / mem_limit,
                        numGroups / ngroups_limit);
  
         nbatches = Max(ceil(nbatches), 1.0);
         num_partitions = Max(num_partitions, 2);
  
         /*
          * The number of partitions can change at different levels of
          * recursion; but for the purposes of this calculation assume it stays
          * constant.
          */
         depth = ceil(log(nbatches) / log(num_partitions));
  
         /*
          * Estimate number of pages read and written. For each level of
          * recursion, a tuple must be written and then later read.
          */
         pages = relation_byte_size(input_tuples, input_width) / BLCKSZ;
         pages_written = pages_read = pages * depth;
  
         /*
          * HashAgg has somewhat worse IO behavior than Sort on typical
          * hardware/OS combinations. Account for this with a generic penalty.
          */
         pages_read *= 2.0;
         pages_written *= 2.0;
  
         startup_cost += pages_written * random_page_cost;
         total_cost += pages_written * random_page_cost;
         total_cost += pages_read * seq_page_cost;
  
         /* account for CPU cost of spilling a tuple and reading it back */
         spill_cost = depth * input_tuples * 2.0 * cpu_tuple_cost;
         startup_cost += spill_cost;
         total_cost += spill_cost;
     }
  
     /*
      * If there are quals (HAVING quals), account for their cost and
      * selectivity.
      */
     if (quals)
     {
         QualCost    qual_cost;
  
         cost_qual_eval(&qual_cost, quals, root);
         startup_cost += qual_cost.startup;
         total_cost += qual_cost.startup + output_tuples * qual_cost.per_tuple;
  
         output_tuples = clamp_row_est(output_tuples *
                                       clauselist_selectivity(root,
                                                              quals,
                                                              0,
                                                              JOIN_INNER,
                                                              NULL));
     }
  
     path->rows = output_tuples;
     path->startup_cost = startup_cost;
     path->total_cost = total_cost;
 }

References AGG_HASHED, AGG_MIXED, AGG_PLAIN, AGG_SORTED, Assert, clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), cpu_operator_cost, cpu_tuple_cost, disable_cost, enable_hashagg, AggClauseCosts::finalCost, hash_agg_entry_size(), hash_agg_set_limits(), JOIN_INNER, list_length(), Max, MemSet, QualCost::per_tuple, random_page_cost, relation_byte_size(), root, Path::rows, seq_page_cost, QualCost::startup, Path::startup_cost, Path::total_cost, AggClauseCosts::transCost, and AggClauseCosts::transitionSpace.

Referenced by choose_hashed_setop(), create_agg_path(), create_groupingsets_path(), and create_unique_path().

◆ cost_append()

void cost_append ( AppendPath * apath )

Definition at line 2210 of file costsize.c.

 {
     ListCell   *l;
  
     apath->path.startup_cost = 0;
     apath->path.total_cost = 0;
     apath->path.rows = 0;
  
     if (apath->subpaths == NIL)
         return;
  
     if (!apath->path.parallel_aware)
     {
         List       *pathkeys = apath->path.pathkeys;
  
         if (pathkeys == NIL)
         {
             Path       *firstsubpath = (Path *) linitial(apath->subpaths);
  
             /*
              * For an unordered, non-parallel-aware Append we take the startup
              * cost as the startup cost of the first subpath.
              */
             apath->path.startup_cost = firstsubpath->startup_cost;
  
             /* Compute rows and costs as sums of subplan rows and costs. */
             foreach(l, apath->subpaths)
             {
                 Path       *subpath = (Path *) lfirst(l);
  
                 apath->path.rows += subpath->rows;
                 apath->path.total_cost += subpath->total_cost;
             }
         }
         else
         {
             /*
              * For an ordered, non-parallel-aware Append we take the startup
              * cost as the sum of the subpath startup costs.  This ensures
              * that we don't underestimate the startup cost when a query's
              * LIMIT is such that several of the children have to be run to
              * satisfy it.  This might be overkill --- another plausible hack
              * would be to take the Append's startup cost as the maximum of
              * the child startup costs.  But we don't want to risk believing
              * that an ORDER BY LIMIT query can be satisfied at small cost
              * when the first child has small startup cost but later ones
              * don't.  (If we had the ability to deal with nonlinear cost
              * interpolation for partial retrievals, we would not need to be
              * so conservative about this.)
              *
              * This case is also different from the above in that we have to
              * account for possibly injecting sorts into subpaths that aren't
              * natively ordered.
              */
             foreach(l, apath->subpaths)
             {
                 Path       *subpath = (Path *) lfirst(l);
                 Path        sort_path;  /* dummy for result of cost_sort */
  
                 if (!pathkeys_contained_in(pathkeys, subpath->pathkeys))
                 {
                     /*
                      * We'll need to insert a Sort node, so include costs for
                      * that.  We can use the parent's LIMIT if any, since we
                      * certainly won't pull more than that many tuples from
                      * any child.
                      */
                     cost_sort(&sort_path,
                               NULL, /* doesn't currently need root */
                               pathkeys,
                               subpath->total_cost,
                               subpath->rows,
                               subpath->pathtarget->width,
                               0.0,
                               work_mem,
                               apath->limit_tuples);
                     subpath = &sort_path;
                 }
  
                 apath->path.rows += subpath->rows;
                 apath->path.startup_cost += subpath->startup_cost;
                 apath->path.total_cost += subpath->total_cost;
             }
         }
     }
     else                        /* parallel-aware */
     {
         int         i = 0;
         double      parallel_divisor = get_parallel_divisor(&apath->path);
  
         /* Parallel-aware Append never produces ordered output. */
         Assert(apath->path.pathkeys == NIL);
  
         /* Calculate startup cost. */
         foreach(l, apath->subpaths)
         {
             Path       *subpath = (Path *) lfirst(l);
  
             /*
              * Append will start returning tuples when the child node having
              * lowest startup cost is done setting up. We consider only the
              * first few subplans that immediately get a worker assigned.
              */
             if (i == 0)
                 apath->path.startup_cost = subpath->startup_cost;
             else if (i < apath->path.parallel_workers)
                 apath->path.startup_cost = Min(apath->path.startup_cost,
                                                subpath->startup_cost);
  
             /*
              * Apply parallel divisor to subpaths.  Scale the number of rows
              * for each partial subpath based on the ratio of the parallel
              * divisor originally used for the subpath to the one we adopted.
              * Also add the cost of partial paths to the total cost, but
              * ignore non-partial paths for now.
              */
             if (i < apath->first_partial_path)
                 apath->path.rows += subpath->rows / parallel_divisor;
             else
             {
                 double      subpath_parallel_divisor;
  
                 subpath_parallel_divisor = get_parallel_divisor(subpath);
                 apath->path.rows += subpath->rows * (subpath_parallel_divisor /
                                                      parallel_divisor);
                 apath->path.total_cost += subpath->total_cost;
             }
  
             apath->path.rows = clamp_row_est(apath->path.rows);
  
             i++;
         }
  
         /* Add cost for non-partial subpaths. */
         apath->path.total_cost +=
             append_nonpartial_cost(apath->subpaths,
                                    apath->first_partial_path,
                                    apath->path.parallel_workers);
     }
  
     /*
      * Although Append does not do any selection or projection, it's not free;
      * add a small per-tuple overhead.
      */
     apath->path.total_cost +=
         cpu_tuple_cost * APPEND_CPU_COST_MULTIPLIER * apath->path.rows;
 }

References APPEND_CPU_COST_MULTIPLIER, append_nonpartial_cost(), Assert, clamp_row_est(), cost_sort(), cpu_tuple_cost, AppendPath::first_partial_path, get_parallel_divisor(), i, lfirst, AppendPath::limit_tuples, linitial, Min, NIL, Path::parallel_aware, Path::parallel_workers, AppendPath::path, Path::pathkeys, pathkeys_contained_in(), Path::rows, Path::startup_cost, subpath(), AppendPath::subpaths, Path::total_cost, and work_mem.

Referenced by create_append_path().

◆ cost_bitmap_and_node()

void cost_bitmap_and_node	(	BitmapAndPath *	path,
		PlannerInfo *	root
	)

Definition at line 1157 of file costsize.c.

 {
     Cost        totalCost;
     Selectivity selec;
     ListCell   *l;
  
     /*
      * We estimate AND selectivity on the assumption that the inputs are
      * independent.  This is probably often wrong, but we don't have the info
      * to do better.
      *
      * The runtime cost of the BitmapAnd itself is estimated at 100x
      * cpu_operator_cost for each tbm_intersect needed.  Probably too small,
      * definitely too simplistic?
      */
     totalCost = 0.0;
     selec = 1.0;
     foreach(l, path->bitmapquals)
     {
         Path       *subpath = (Path *) lfirst(l);
         Cost        subCost;
         Selectivity subselec;
  
         cost_bitmap_tree_node(subpath, &subCost, &subselec);
  
         selec *= subselec;
  
         totalCost += subCost;
         if (l != list_head(path->bitmapquals))
             totalCost += 100.0 * cpu_operator_cost;
     }
     path->bitmapselectivity = selec;
     path->path.rows = 0;        /* per above, not used */
     path->path.startup_cost = totalCost;
     path->path.total_cost = totalCost;
 }

References BitmapAndPath::bitmapquals, BitmapAndPath::bitmapselectivity, cost_bitmap_tree_node(), cpu_operator_cost, lfirst, list_head(), BitmapAndPath::path, Path::rows, Path::startup_cost, subpath(), and Path::total_cost.

Referenced by create_bitmap_and_path().

◆ cost_bitmap_heap_scan()

void cost_bitmap_heap_scan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info,
		Path *	bitmapqual,
		double	loop_count
	)

Definition at line 1013 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     Cost        indexTotalCost;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     Cost        cost_per_page;
     Cost        cpu_run_cost;
     double      tuples_fetched;
     double      pages_fetched;
     double      spc_seq_page_cost,
                 spc_random_page_cost;
     double      T;
  
     /* Should only be applied to base relations */
     Assert(IsA(baserel, RelOptInfo));
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RELATION);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     if (!enable_bitmapscan)
         startup_cost += disable_cost;
  
     pages_fetched = compute_bitmap_pages(root, baserel, bitmapqual,
                                          loop_count, &indexTotalCost,
                                          &tuples_fetched);
  
     startup_cost += indexTotalCost;
     T = (baserel->pages > 1) ? (double) baserel->pages : 1.0;
  
     /* Fetch estimated page costs for tablespace containing table. */
     get_tablespace_page_costs(baserel->reltablespace,
                               &spc_random_page_cost,
                               &spc_seq_page_cost);
  
     /*
      * For small numbers of pages we should charge spc_random_page_cost
      * apiece, while if nearly all the table's pages are being read, it's more
      * appropriate to charge spc_seq_page_cost apiece.  The effect is
      * nonlinear, too. For lack of a better idea, interpolate like this to
      * determine the cost per page.
      */
     if (pages_fetched >= 2.0)
         cost_per_page = spc_random_page_cost -
             (spc_random_page_cost - spc_seq_page_cost)
             * sqrt(pages_fetched / T);
     else
         cost_per_page = spc_random_page_cost;
  
     run_cost += pages_fetched * cost_per_page;
  
     /*
      * Estimate CPU costs per tuple.
      *
      * Often the indexquals don't need to be rechecked at each tuple ... but
      * not always, especially not if there are enough tuples involved that the
      * bitmaps become lossy.  For the moment, just assume they will be
      * rechecked always.  This means we charge the full freight for all the
      * scan clauses.
      */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     cpu_run_cost = cpu_per_tuple * tuples_fetched;
  
     /* Adjust costing for parallelism, if used. */
     if (path->parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(path);
  
         /* The CPU cost is divided among all the workers. */
         cpu_run_cost /= parallel_divisor;
  
         path->rows = clamp_row_est(path->rows / parallel_divisor);
     }
  
  
     run_cost += cpu_run_cost;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, clamp_row_est(), compute_bitmap_pages(), cpu_tuple_cost, disable_cost, enable_bitmapscan, get_parallel_divisor(), get_restriction_qual_cost(), get_tablespace_page_costs(), IsA, RelOptInfo::pages, Path::parallel_workers, QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, T, and Path::total_cost.

Referenced by bitmap_scan_cost_est(), and create_bitmap_heap_path().

◆ cost_bitmap_or_node()

void cost_bitmap_or_node	(	BitmapOrPath *	path,
		PlannerInfo *	root
	)

Definition at line 1201 of file costsize.c.

 {
     Cost        totalCost;
     Selectivity selec;
     ListCell   *l;
  
     /*
      * We estimate OR selectivity on the assumption that the inputs are
      * non-overlapping, since that's often the case in "x IN (list)" type
      * situations.  Of course, we clamp to 1.0 at the end.
      *
      * The runtime cost of the BitmapOr itself is estimated at 100x
      * cpu_operator_cost for each tbm_union needed.  Probably too small,
      * definitely too simplistic?  We are aware that the tbm_unions are
      * optimized out when the inputs are BitmapIndexScans.
      */
     totalCost = 0.0;
     selec = 0.0;
     foreach(l, path->bitmapquals)
     {
         Path       *subpath = (Path *) lfirst(l);
         Cost        subCost;
         Selectivity subselec;
  
         cost_bitmap_tree_node(subpath, &subCost, &subselec);
  
         selec += subselec;
  
         totalCost += subCost;
         if (l != list_head(path->bitmapquals) &&
             !IsA(subpath, IndexPath))
             totalCost += 100.0 * cpu_operator_cost;
     }
     path->bitmapselectivity = Min(selec, 1.0);
     path->path.rows = 0;        /* per above, not used */
     path->path.startup_cost = totalCost;
     path->path.total_cost = totalCost;
 }

References BitmapOrPath::bitmapquals, BitmapOrPath::bitmapselectivity, cost_bitmap_tree_node(), cpu_operator_cost, IsA, lfirst, list_head(), Min, BitmapOrPath::path, Path::rows, Path::startup_cost, subpath(), and Path::total_cost.

Referenced by create_bitmap_or_path().

◆ cost_bitmap_tree_node()

void cost_bitmap_tree_node	(	Path *	path,
		Cost *	cost,
		Selectivity *	selec
	)

Definition at line 1114 of file costsize.c.

 {
     if (IsA(path, IndexPath))
     {
         *cost = ((IndexPath *) path)->indextotalcost;
         *selec = ((IndexPath *) path)->indexselectivity;
  
         /*
          * Charge a small amount per retrieved tuple to reflect the costs of
          * manipulating the bitmap.  This is mostly to make sure that a bitmap
          * scan doesn't look to be the same cost as an indexscan to retrieve a
          * single tuple.
          */
         *cost += 0.1 * cpu_operator_cost * path->rows;
     }
     else if (IsA(path, BitmapAndPath))
     {
         *cost = path->total_cost;
         *selec = ((BitmapAndPath *) path)->bitmapselectivity;
     }
     else if (IsA(path, BitmapOrPath))
     {
         *cost = path->total_cost;
         *selec = ((BitmapOrPath *) path)->bitmapselectivity;
     }
     else
     {
         elog(ERROR, "unrecognized node type: %d", nodeTag(path));
         *cost = *selec = 0;     /* keep compiler quiet */
     }
 }

References cpu_operator_cost, elog, ERROR, IsA, nodeTag, Path::rows, and Path::total_cost.

Referenced by choose_bitmap_and(), compute_bitmap_pages(), cost_bitmap_and_node(), cost_bitmap_or_node(), and path_usage_comparator().

◆ cost_ctescan()

void cost_ctescan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1677 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations that are CTEs */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_CTE);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* Charge one CPU tuple cost per row for tuplestore manipulation */
     cpu_per_tuple = cpu_tuple_cost;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple += cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cpu_tuple_cost, get_restriction_qual_cost(), QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_CTE, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_ctescan_path(), and create_worktablescan_path().

◆ cost_functionscan()

void cost_functionscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1510 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     RangeTblEntry *rte;
     QualCost    exprcost;
  
     /* Should only be applied to base relations that are functions */
     Assert(baserel->relid > 0);
     rte = planner_rt_fetch(baserel->relid, root);
     Assert(rte->rtekind == RTE_FUNCTION);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /*
      * Estimate costs of executing the function expression(s).
      *
      * Currently, nodeFunctionscan.c always executes the functions to
      * completion before returning any rows, and caches the results in a
      * tuplestore.  So the function eval cost is all startup cost, and per-row
      * costs are minimal.
      *
      * XXX in principle we ought to charge tuplestore spill costs if the
      * number of rows is large.  However, given how phony our rowcount
      * estimates for functions tend to be, there's not a lot of point in that
      * refinement right now.
      */
     cost_qual_eval_node(&exprcost, (Node *) rte->functions, root);
  
     startup_cost += exprcost.startup + exprcost.per_tuple;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cost_qual_eval_node(), cpu_tuple_cost, RangeTblEntry::functions, get_restriction_qual_cost(), QualCost::per_tuple, planner_rt_fetch, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_FUNCTION, RangeTblEntry::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_functionscan_path().

◆ cost_gather()

void cost_gather	(	GatherPath *	path,
		PlannerInfo *	root,
		RelOptInfo *	rel,
		ParamPathInfo *	param_info,
		double *	rows
	)

Definition at line 436 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
  
     /* Mark the path with the correct row estimate */
     if (rows)
         path->path.rows = *rows;
     else if (param_info)
         path->path.rows = param_info->ppi_rows;
     else
         path->path.rows = rel->rows;
  
     startup_cost = path->subpath->startup_cost;
  
     run_cost = path->subpath->total_cost - path->subpath->startup_cost;
  
     /* Parallel setup and communication cost. */
     startup_cost += parallel_setup_cost;
     run_cost += parallel_tuple_cost * path->path.rows;
  
     path->path.startup_cost = startup_cost;
     path->path.total_cost = (startup_cost + run_cost);
 }

References parallel_setup_cost, parallel_tuple_cost, GatherPath::path, ParamPathInfo::ppi_rows, RelOptInfo::rows, Path::rows, Path::startup_cost, GatherPath::subpath, and Path::total_cost.

Referenced by create_gather_path().

◆ cost_gather_merge()

void cost_gather_merge	(	GatherMergePath *	path,
		PlannerInfo *	root,
		RelOptInfo *	rel,
		ParamPathInfo *	param_info,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double *	rows
	)

Definition at line 474 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     Cost        comparison_cost;
     double      N;
     double      logN;
  
     /* Mark the path with the correct row estimate */
     if (rows)
         path->path.rows = *rows;
     else if (param_info)
         path->path.rows = param_info->ppi_rows;
     else
         path->path.rows = rel->rows;
  
     if (!enable_gathermerge)
         startup_cost += disable_cost;
  
     /*
      * Add one to the number of workers to account for the leader.  This might
      * be overgenerous since the leader will do less work than other workers
      * in typical cases, but we'll go with it for now.
      */
     Assert(path->num_workers > 0);
     N = (double) path->num_workers + 1;
     logN = LOG2(N);
  
     /* Assumed cost per tuple comparison */
     comparison_cost = 2.0 * cpu_operator_cost;
  
     /* Heap creation cost */
     startup_cost += comparison_cost * N * logN;
  
     /* Per-tuple heap maintenance cost */
     run_cost += path->path.rows * comparison_cost * logN;
  
     /* small cost for heap management, like cost_merge_append */
     run_cost += cpu_operator_cost * path->path.rows;
  
     /*
      * Parallel setup and communication cost.  Since Gather Merge, unlike
      * Gather, requires us to block until a tuple is available from every
      * worker, we bump the IPC cost up a little bit as compared with Gather.
      * For lack of a better idea, charge an extra 5%.
      */
     startup_cost += parallel_setup_cost;
     run_cost += parallel_tuple_cost * path->path.rows * 1.05;
  
     path->path.startup_cost = startup_cost + input_startup_cost;
     path->path.total_cost = (startup_cost + run_cost + input_total_cost);
 }

References Assert, cpu_operator_cost, disable_cost, enable_gathermerge, LOG2, GatherMergePath::num_workers, parallel_setup_cost, parallel_tuple_cost, GatherMergePath::path, ParamPathInfo::ppi_rows, RelOptInfo::rows, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by create_gather_merge_path().

◆ cost_group()

void cost_group	(	Path *	path,
		PlannerInfo *	root,
		int	numGroupCols,
		double	numGroups,
		List *	quals,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	input_tuples
	)

Definition at line 3142 of file costsize.c.

 {
     double      output_tuples;
     Cost        startup_cost;
     Cost        total_cost;
  
     output_tuples = numGroups;
     startup_cost = input_startup_cost;
     total_cost = input_total_cost;
  
     /*
      * Charge one cpu_operator_cost per comparison per input tuple. We assume
      * all columns get compared at most of the tuples.
      */
     total_cost += cpu_operator_cost * input_tuples * numGroupCols;
  
     /*
      * If there are quals (HAVING quals), account for their cost and
      * selectivity.
      */
     if (quals)
     {
         QualCost    qual_cost;
  
         cost_qual_eval(&qual_cost, quals, root);
         startup_cost += qual_cost.startup;
         total_cost += qual_cost.startup + output_tuples * qual_cost.per_tuple;
  
         output_tuples = clamp_row_est(output_tuples *
                                       clauselist_selectivity(root,
                                                              quals,
                                                              0,
                                                              JOIN_INNER,
                                                              NULL));
     }
  
     path->rows = output_tuples;
     path->startup_cost = startup_cost;
     path->total_cost = total_cost;
 }

References clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), cpu_operator_cost, JOIN_INNER, QualCost::per_tuple, root, Path::rows, QualCost::startup, Path::startup_cost, and Path::total_cost.

Referenced by choose_hashed_setop(), and create_group_path().

◆ cost_incremental_sort()

void cost_incremental_sort	(	Path *	path,
		PlannerInfo *	root,
		List *	pathkeys,
		int	presorted_keys,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	input_tuples,
		int	width,
		Cost	comparison_cost,
		int	sort_mem,
		double	limit_tuples
	)

Definition at line 1965 of file costsize.c.

 {
     Cost        startup_cost,
                 run_cost,
                 input_run_cost = input_total_cost - input_startup_cost;
     double      group_tuples,
                 input_groups;
     Cost        group_startup_cost,
                 group_run_cost,
                 group_input_run_cost;
     List       *presortedExprs = NIL;
     ListCell   *l;
     bool        unknown_varno = false;
  
     Assert(presorted_keys > 0 && presorted_keys < list_length(pathkeys));
  
     /*
      * We want to be sure the cost of a sort is never estimated as zero, even
      * if passed-in tuple count is zero.  Besides, mustn't do log(0)...
      */
     if (input_tuples < 2.0)
         input_tuples = 2.0;
  
     /* Default estimate of number of groups, capped to one group per row. */
     input_groups = Min(input_tuples, DEFAULT_NUM_DISTINCT);
  
     /*
      * Extract presorted keys as list of expressions.
      *
      * We need to be careful about Vars containing "varno 0" which might have
      * been introduced by generate_append_tlist, which would confuse
      * estimate_num_groups (in fact it'd fail for such expressions). See
      * recurse_set_operations which has to deal with the same issue.
      *
      * Unlike recurse_set_operations we can't access the original target list
      * here, and even if we could it's not very clear how useful would that be
      * for a set operation combining multiple tables. So we simply detect if
      * there are any expressions with "varno 0" and use the default
      * DEFAULT_NUM_DISTINCT in that case.
      *
      * We might also use either 1.0 (a single group) or input_tuples (each row
      * being a separate group), pretty much the worst and best case for
      * incremental sort. But those are extreme cases and using something in
      * between seems reasonable. Furthermore, generate_append_tlist is used
      * for set operations, which are likely to produce mostly unique output
      * anyway - from that standpoint the DEFAULT_NUM_DISTINCT is defensive
      * while maintaining lower startup cost.
      */
     foreach(l, pathkeys)
     {
         PathKey    *key = (PathKey *) lfirst(l);
         EquivalenceMember *member = (EquivalenceMember *)
             linitial(key->pk_eclass->ec_members);
  
         /*
          * Check if the expression contains Var with "varno 0" so that we
          * don't call estimate_num_groups in that case.
          */
         if (bms_is_member(0, pull_varnos(root, (Node *) member->em_expr)))
         {
             unknown_varno = true;
             break;
         }
  
         /* expression not containing any Vars with "varno 0" */
         presortedExprs = lappend(presortedExprs, member->em_expr);
  
         if (foreach_current_index(l) + 1 >= presorted_keys)
             break;
     }
  
     /* Estimate the number of groups with equal presorted keys. */
     if (!unknown_varno)
         input_groups = estimate_num_groups(root, presortedExprs, input_tuples,
                                            NULL, NULL);
  
     group_tuples = input_tuples / input_groups;
     group_input_run_cost = input_run_cost / input_groups;
  
     /*
      * Estimate the average cost of sorting of one group where presorted keys
      * are equal.
      */
     cost_tuplesort(&group_startup_cost, &group_run_cost,
                    group_tuples, width, comparison_cost, sort_mem,
                    limit_tuples);
  
     /*
      * Startup cost of incremental sort is the startup cost of its first group
      * plus the cost of its input.
      */
     startup_cost = group_startup_cost + input_startup_cost +
         group_input_run_cost;
  
     /*
      * After we started producing tuples from the first group, the cost of
      * producing all the tuples is given by the cost to finish processing this
      * group, plus the total cost to process the remaining groups, plus the
      * remaining cost of input.
      */
     run_cost = group_run_cost + (group_run_cost + group_startup_cost) *
         (input_groups - 1) + group_input_run_cost * (input_groups - 1);
  
     /*
      * Incremental sort adds some overhead by itself. Firstly, it has to
      * detect the sort groups. This is roughly equal to one extra copy and
      * comparison per tuple.
      */
     run_cost += (cpu_tuple_cost + comparison_cost) * input_tuples;
  
     /*
      * Additionally, we charge double cpu_tuple_cost for each input group to
      * account for the tuplesort_reset that's performed after each group.
      */
     run_cost += 2.0 * cpu_tuple_cost * input_groups;
  
     path->rows = input_tuples;
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, bms_is_member(), cost_tuplesort(), cpu_tuple_cost, DEFAULT_NUM_DISTINCT, EquivalenceMember::em_expr, estimate_num_groups(), foreach_current_index, sort-test::key, lappend(), lfirst, linitial, list_length(), Min, NIL, pull_varnos(), root, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by create_incremental_sort_path().

◆ cost_index()

void cost_index	(	IndexPath *	path,
		PlannerInfo *	root,
		double	loop_count,
		bool	partial_path
	)

Definition at line 549 of file costsize.c.

 {
     IndexOptInfo *index = path->indexinfo;
     RelOptInfo *baserel = index->rel;
     bool        indexonly = (path->path.pathtype == T_IndexOnlyScan);
     amcostestimate_function amcostestimate;
     List       *qpquals;
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     Cost        cpu_run_cost = 0;
     Cost        indexStartupCost;
     Cost        indexTotalCost;
     Selectivity indexSelectivity;
     double      indexCorrelation,
                 csquared;
     double      spc_seq_page_cost,
                 spc_random_page_cost;
     Cost        min_IO_cost,
                 max_IO_cost;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     double      tuples_fetched;
     double      pages_fetched;
     double      rand_heap_pages;
     double      index_pages;
  
     /* Should only be applied to base relations */
     Assert(IsA(baserel, RelOptInfo) &&
            IsA(index, IndexOptInfo));
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RELATION);
  
     /*
      * Mark the path with the correct row estimate, and identify which quals
      * will need to be enforced as qpquals.  We need not check any quals that
      * are implied by the index's predicate, so we can use indrestrictinfo not
      * baserestrictinfo as the list of relevant restriction clauses for the
      * rel.
      */
     if (path->path.param_info)
     {
         path->path.rows = path->path.param_info->ppi_rows;
         /* qpquals come from the rel's restriction clauses and ppi_clauses */
         qpquals = list_concat(extract_nonindex_conditions(path->indexinfo->indrestrictinfo,
                                                           path->indexclauses),
                               extract_nonindex_conditions(path->path.param_info->ppi_clauses,
                                                           path->indexclauses));
     }
     else
     {
         path->path.rows = baserel->rows;
         /* qpquals come from just the rel's restriction clauses */
         qpquals = extract_nonindex_conditions(path->indexinfo->indrestrictinfo,
                                               path->indexclauses);
     }
  
     if (!enable_indexscan)
         startup_cost += disable_cost;
     /* we don't need to check enable_indexonlyscan; indxpath.c does that */
  
     /*
      * Call index-access-method-specific code to estimate the processing cost
      * for scanning the index, as well as the selectivity of the index (ie,
      * the fraction of main-table tuples we will have to retrieve) and its
      * correlation to the main-table tuple order.  We need a cast here because
      * pathnodes.h uses a weak function type to avoid including amapi.h.
      */
     amcostestimate = (amcostestimate_function) index->amcostestimate;
     amcostestimate(root, path, loop_count,
                    &indexStartupCost, &indexTotalCost,
                    &indexSelectivity, &indexCorrelation,
                    &index_pages);
  
     /*
      * Save amcostestimate's results for possible use in bitmap scan planning.
      * We don't bother to save indexStartupCost or indexCorrelation, because a
      * bitmap scan doesn't care about either.
      */
     path->indextotalcost = indexTotalCost;
     path->indexselectivity = indexSelectivity;
  
     /* all costs for touching index itself included here */
     startup_cost += indexStartupCost;
     run_cost += indexTotalCost - indexStartupCost;
  
     /* estimate number of main-table tuples fetched */
     tuples_fetched = clamp_row_est(indexSelectivity * baserel->tuples);
  
     /* fetch estimated page costs for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
                               &spc_random_page_cost,
                               &spc_seq_page_cost);
  
     /*----------
      * Estimate number of main-table pages fetched, and compute I/O cost.
      *
      * When the index ordering is uncorrelated with the table ordering,
      * we use an approximation proposed by Mackert and Lohman (see
      * index_pages_fetched() for details) to compute the number of pages
      * fetched, and then charge spc_random_page_cost per page fetched.
      *
      * When the index ordering is exactly correlated with the table ordering
      * (just after a CLUSTER, for example), the number of pages fetched should
      * be exactly selectivity * table_size.  What's more, all but the first
      * will be sequential fetches, not the random fetches that occur in the
      * uncorrelated case.  So if the number of pages is more than 1, we
      * ought to charge
      *      spc_random_page_cost + (pages_fetched - 1) * spc_seq_page_cost
      * For partially-correlated indexes, we ought to charge somewhere between
      * these two estimates.  We currently interpolate linearly between the
      * estimates based on the correlation squared (XXX is that appropriate?).
      *
      * If it's an index-only scan, then we will not need to fetch any heap
      * pages for which the visibility map shows all tuples are visible.
      * Hence, reduce the estimated number of heap fetches accordingly.
      * We use the measured fraction of the entire heap that is all-visible,
      * which might not be particularly relevant to the subset of the heap
      * that this query will fetch; but it's not clear how to do better.
      *----------
      */
     if (loop_count > 1)
     {
         /*
          * For repeated indexscans, the appropriate estimate for the
          * uncorrelated case is to scale up the number of tuples fetched in
          * the Mackert and Lohman formula by the number of scans, so that we
          * estimate the number of pages fetched by all the scans; then
          * pro-rate the costs for one scan.  In this case we assume all the
          * fetches are random accesses.
          */
         pages_fetched = index_pages_fetched(tuples_fetched * loop_count,
                                             baserel->pages,
                                             (double) index->pages,
                                             root);
  
         if (indexonly)
             pages_fetched = ceil(pages_fetched * (1.0 - baserel->allvisfrac));
  
         rand_heap_pages = pages_fetched;
  
         max_IO_cost = (pages_fetched * spc_random_page_cost) / loop_count;
  
         /*
          * In the perfectly correlated case, the number of pages touched by
          * each scan is selectivity * table_size, and we can use the Mackert
          * and Lohman formula at the page level to estimate how much work is
          * saved by caching across scans.  We still assume all the fetches are
          * random, though, which is an overestimate that's hard to correct for
          * without double-counting the cache effects.  (But in most cases
          * where such a plan is actually interesting, only one page would get
          * fetched per scan anyway, so it shouldn't matter much.)
          */
         pages_fetched = ceil(indexSelectivity * (double) baserel->pages);
  
         pages_fetched = index_pages_fetched(pages_fetched * loop_count,
                                             baserel->pages,
                                             (double) index->pages,
                                             root);
  
         if (indexonly)
             pages_fetched = ceil(pages_fetched * (1.0 - baserel->allvisfrac));
  
         min_IO_cost = (pages_fetched * spc_random_page_cost) / loop_count;
     }
     else
     {
         /*
          * Normal case: apply the Mackert and Lohman formula, and then
          * interpolate between that and the correlation-derived result.
          */
         pages_fetched = index_pages_fetched(tuples_fetched,
                                             baserel->pages,
                                             (double) index->pages,
                                             root);
  
         if (indexonly)
             pages_fetched = ceil(pages_fetched * (1.0 - baserel->allvisfrac));
  
         rand_heap_pages = pages_fetched;
  
         /* max_IO_cost is for the perfectly uncorrelated case (csquared=0) */
         max_IO_cost = pages_fetched * spc_random_page_cost;
  
         /* min_IO_cost is for the perfectly correlated case (csquared=1) */
         pages_fetched = ceil(indexSelectivity * (double) baserel->pages);
  
         if (indexonly)
             pages_fetched = ceil(pages_fetched * (1.0 - baserel->allvisfrac));
  
         if (pages_fetched > 0)
         {
             min_IO_cost = spc_random_page_cost;
             if (pages_fetched > 1)
                 min_IO_cost += (pages_fetched - 1) * spc_seq_page_cost;
         }
         else
             min_IO_cost = 0;
     }
  
     if (partial_path)
     {
         /*
          * For index only scans compute workers based on number of index pages
          * fetched; the number of heap pages we fetch might be so small as to
          * effectively rule out parallelism, which we don't want to do.
          */
         if (indexonly)
             rand_heap_pages = -1;
  
         /*
          * Estimate the number of parallel workers required to scan index. Use
          * the number of heap pages computed considering heap fetches won't be
          * sequential as for parallel scans the pages are accessed in random
          * order.
          */
         path->path.parallel_workers = compute_parallel_worker(baserel,
                                                               rand_heap_pages,
                                                               index_pages,
                                                               max_parallel_workers_per_gather);
  
         /*
          * Fall out if workers can't be assigned for parallel scan, because in
          * such a case this path will be rejected.  So there is no benefit in
          * doing extra computation.
          */
         if (path->path.parallel_workers <= 0)
             return;
  
         path->path.parallel_aware = true;
     }
  
     /*
      * Now interpolate based on estimated index order correlation to get total
      * disk I/O cost for main table accesses.
      */
     csquared = indexCorrelation * indexCorrelation;
  
     run_cost += max_IO_cost + csquared * (min_IO_cost - max_IO_cost);
  
     /*
      * Estimate CPU costs per tuple.
      *
      * What we want here is cpu_tuple_cost plus the evaluation costs of any
      * qual clauses that we have to evaluate as qpquals.
      */
     cost_qual_eval(&qpqual_cost, qpquals, root);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
  
     cpu_run_cost += cpu_per_tuple * tuples_fetched;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->path.pathtarget->cost.startup;
     cpu_run_cost += path->path.pathtarget->cost.per_tuple * path->path.rows;
  
     /* Adjust costing for parallelism, if used. */
     if (path->path.parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(&path->path);
  
         path->path.rows = clamp_row_est(path->path.rows / parallel_divisor);
  
         /* The CPU cost is divided among all the workers. */
         cpu_run_cost /= parallel_divisor;
     }
  
     run_cost += cpu_run_cost;
  
     path->path.startup_cost = startup_cost;
     path->path.total_cost = startup_cost + run_cost;
 }

References RelOptInfo::allvisfrac, Assert, clamp_row_est(), compute_parallel_worker(), cost_qual_eval(), cpu_tuple_cost, disable_cost, enable_indexscan, extract_nonindex_conditions(), get_parallel_divisor(), get_tablespace_page_costs(), index_pages_fetched(), IndexPath::indexclauses, IndexPath::indexinfo, IndexPath::indexselectivity, IndexPath::indextotalcost, IndexOptInfo::indrestrictinfo, IsA, list_concat(), max_parallel_workers_per_gather, RelOptInfo::pages, Path::parallel_aware, Path::parallel_workers, IndexPath::path, Path::pathtype, QualCost::per_tuple, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_index_path(), and reparameterize_path().

◆ cost_material()

void cost_material	(	Path *	path,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	tuples,
		int	width
	)

Definition at line 2432 of file costsize.c.

 {
     Cost        startup_cost = input_startup_cost;
     Cost        run_cost = input_total_cost - input_startup_cost;
     double      nbytes = relation_byte_size(tuples, width);
     long        work_mem_bytes = work_mem * 1024L;
  
     path->rows = tuples;
  
     /*
      * Whether spilling or not, charge 2x cpu_operator_cost per tuple to
      * reflect bookkeeping overhead.  (This rate must be more than what
      * cost_rescan charges for materialize, ie, cpu_operator_cost per tuple;
      * if it is exactly the same then there will be a cost tie between
      * nestloop with A outer, materialized B inner and nestloop with B outer,
      * materialized A inner.  The extra cost ensures we'll prefer
      * materializing the smaller rel.)  Note that this is normally a good deal
      * less than cpu_tuple_cost; which is OK because a Material plan node
      * doesn't do qual-checking or projection, so it's got less overhead than
      * most plan nodes.
      */
     run_cost += 2 * cpu_operator_cost * tuples;
  
     /*
      * If we will spill to disk, charge at the rate of seq_page_cost per page.
      * This cost is assumed to be evenly spread through the plan run phase,
      * which isn't exactly accurate but our cost model doesn't allow for
      * nonuniform costs within the run phase.
      */
     if (nbytes > work_mem_bytes)
     {
         double      npages = ceil(nbytes / BLCKSZ);
  
         run_cost += seq_page_cost * npages;
     }
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References cpu_operator_cost, relation_byte_size(), Path::rows, seq_page_cost, Path::startup_cost, Path::total_cost, and work_mem.

Referenced by create_material_path(), and materialize_finished_plan().

◆ cost_merge_append()

void cost_merge_append	(	Path *	path,
		PlannerInfo *	root,
		List *	pathkeys,
		int	n_streams,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	tuples
	)

Definition at line 2383 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     Cost        comparison_cost;
     double      N;
     double      logN;
  
     /*
      * Avoid log(0)...
      */
     N = (n_streams < 2) ? 2.0 : (double) n_streams;
     logN = LOG2(N);
  
     /* Assumed cost per tuple comparison */
     comparison_cost = 2.0 * cpu_operator_cost;
  
     /* Heap creation cost */
     startup_cost += comparison_cost * N * logN;
  
     /* Per-tuple heap maintenance cost */
     run_cost += tuples * comparison_cost * logN;
  
     /*
      * Although MergeAppend does not do any selection or projection, it's not
      * free; add a small per-tuple overhead.
      */
     run_cost += cpu_tuple_cost * APPEND_CPU_COST_MULTIPLIER * tuples;
  
     path->startup_cost = startup_cost + input_startup_cost;
     path->total_cost = startup_cost + run_cost + input_total_cost;
 }

References APPEND_CPU_COST_MULTIPLIER, cpu_operator_cost, cpu_tuple_cost, LOG2, Path::startup_cost, and Path::total_cost.

Referenced by create_merge_append_path().

◆ cost_namedtuplestorescan()

void cost_namedtuplestorescan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1718 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations that are Tuplestores */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_NAMEDTUPLESTORE);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* Charge one CPU tuple cost per row for tuplestore manipulation */
     cpu_per_tuple = cpu_tuple_cost;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple += cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cpu_tuple_cost, get_restriction_qual_cost(), QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_NAMEDTUPLESTORE, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_namedtuplestorescan_path().

◆ cost_qual_eval()

void cost_qual_eval	(	QualCost *	cost,
		List *	quals,
		PlannerInfo *	root
	)

Definition at line 4619 of file costsize.c.

 {
     cost_qual_eval_context context;
     ListCell   *l;
  
     context.root = root;
     context.total.startup = 0;
     context.total.per_tuple = 0;
  
     /* We don't charge any cost for the implicit ANDing at top level ... */
  
     foreach(l, quals)
     {
         Node       *qual = (Node *) lfirst(l);
  
         cost_qual_eval_walker(qual, &context);
     }
  
     *cost = context.total;
 }

References context, cost_qual_eval_walker(), lfirst, and root.

Referenced by add_foreign_grouping_paths(), cost_agg(), cost_group(), cost_index(), cost_subplan(), cost_tidrangescan(), cost_tidscan(), create_group_result_path(), create_minmaxagg_path(), estimate_path_cost_size(), final_cost_hashjoin(), final_cost_mergejoin(), final_cost_nestloop(), get_restriction_qual_cost(), inline_function(), plan_cluster_use_sort(), postgresGetForeignJoinPaths(), postgresGetForeignRelSize(), set_baserel_size_estimates(), and set_foreign_size_estimates().

◆ cost_qual_eval_node()

void cost_qual_eval_node	(	QualCost *	cost,
		Node *	qual,
		PlannerInfo *	root
	)

Definition at line 4645 of file costsize.c.

 {
     cost_qual_eval_context context;
  
     context.root = root;
     context.total.startup = 0;
     context.total.per_tuple = 0;
  
     cost_qual_eval_walker(qual, &context);
  
     *cost = context.total;
 }

References context, cost_qual_eval_walker(), and root.

Referenced by add_placeholders_to_joinrel(), cost_functionscan(), cost_qual_eval_walker(), cost_tablefuncscan(), cost_windowagg(), find_simplified_clause(), get_agg_clause_costs(), index_other_operands_eval_cost(), make_sort_input_target(), order_qual_clauses(), set_pathtarget_cost_width(), and set_rel_width().

◆ cost_recursive_union()

void cost_recursive_union	(	Path *	runion,
		Path *	nrterm,
		Path *	rterm
	)

Definition at line 1792 of file costsize.c.

 {
     Cost        startup_cost;
     Cost        total_cost;
     double      total_rows;
  
     /* We probably have decent estimates for the non-recursive term */
     startup_cost = nrterm->startup_cost;
     total_cost = nrterm->total_cost;
     total_rows = nrterm->rows;
  
     /*
      * We arbitrarily assume that about 10 recursive iterations will be
      * needed, and that we've managed to get a good fix on the cost and output
      * size of each one of them.  These are mighty shaky assumptions but it's
      * hard to see how to do better.
      */
     total_cost += 10 * rterm->total_cost;
     total_rows += 10 * rterm->rows;
  
     /*
      * Also charge cpu_tuple_cost per row to account for the costs of
      * manipulating the tuplestores.  (We don't worry about possible
      * spill-to-disk costs.)
      */
     total_cost += cpu_tuple_cost * total_rows;
  
     runion->startup_cost = startup_cost;
     runion->total_cost = total_cost;
     runion->rows = total_rows;
     runion->pathtarget->width = Max(nrterm->pathtarget->width,
                                     rterm->pathtarget->width);
 }

References cpu_tuple_cost, Max, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by create_recursiveunion_path().

◆ cost_resultscan()

void cost_resultscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1755 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to RTE_RESULT base relations */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RESULT);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* We charge qual cost plus cpu_tuple_cost */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cpu_tuple_cost, get_restriction_qual_cost(), QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_RESULT, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_resultscan_path().

◆ cost_samplescan()

void cost_samplescan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 361 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     RangeTblEntry *rte;
     TableSampleClause *tsc;
     TsmRoutine *tsm;
     double      spc_seq_page_cost,
                 spc_random_page_cost,
                 spc_page_cost;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations with tablesample clauses */
     Assert(baserel->relid > 0);
     rte = planner_rt_fetch(baserel->relid, root);
     Assert(rte->rtekind == RTE_RELATION);
     tsc = rte->tablesample;
     Assert(tsc != NULL);
     tsm = GetTsmRoutine(tsc->tsmhandler);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* fetch estimated page cost for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
                               &spc_random_page_cost,
                               &spc_seq_page_cost);
  
     /* if NextSampleBlock is used, assume random access, else sequential */
     spc_page_cost = (tsm->NextSampleBlock != NULL) ?
         spc_random_page_cost : spc_seq_page_cost;
  
     /*
      * disk costs (recall that baserel->pages has already been set to the
      * number of pages the sampling method will visit)
      */
     run_cost += spc_page_cost * baserel->pages;
  
     /*
      * CPU costs (recall that baserel->tuples has already been set to the
      * number of tuples the sampling method will select).  Note that we ignore
      * execution cost of the TABLESAMPLE parameter expressions; they will be
      * evaluated only once per scan, and in most usages they'll likely be
      * simple constants anyway.  We also don't charge anything for the
      * calculations the sampling method might do internally.
      */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cpu_tuple_cost, get_restriction_qual_cost(), get_tablespace_page_costs(), GetTsmRoutine(), TsmRoutine::NextSampleBlock, RelOptInfo::pages, QualCost::per_tuple, planner_rt_fetch, ParamPathInfo::ppi_rows, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RangeTblEntry::rtekind, QualCost::startup, Path::startup_cost, RangeTblEntry::tablesample, Path::total_cost, TableSampleClause::tsmhandler, and RelOptInfo::tuples.

Referenced by create_samplescan_path().

◆ cost_seqscan()

void cost_seqscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 284 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        cpu_run_cost;
     Cost        disk_run_cost;
     double      spc_seq_page_cost;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RELATION);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     if (!enable_seqscan)
         startup_cost += disable_cost;
  
     /* fetch estimated page cost for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
                               NULL,
                               &spc_seq_page_cost);
  
     /*
      * disk costs
      */
     disk_run_cost = spc_seq_page_cost * baserel->pages;
  
     /* CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     cpu_run_cost = cpu_per_tuple * baserel->tuples;
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     cpu_run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     /* Adjust costing for parallelism, if used. */
     if (path->parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(path);
  
         /* The CPU cost is divided among all the workers. */
         cpu_run_cost /= parallel_divisor;
  
         /*
          * It may be possible to amortize some of the I/O cost, but probably
          * not very much, because most operating systems already do aggressive
          * prefetching.  For now, we assume that the disk run cost can't be
          * amortized at all.
          */
  
         /*
          * In the case of a parallel plan, the row count needs to represent
          * the number of tuples processed per worker.
          */
         path->rows = clamp_row_est(path->rows / parallel_divisor);
     }
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + cpu_run_cost + disk_run_cost;
 }

References Assert, clamp_row_est(), cpu_tuple_cost, disable_cost, enable_seqscan, get_parallel_divisor(), get_restriction_qual_cost(), get_tablespace_page_costs(), RelOptInfo::pages, Path::parallel_workers, QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_seqscan_path().

◆ cost_sort()

void cost_sort	(	Path *	path,
		PlannerInfo *	root,
		List *	pathkeys,
		Cost	input_cost,
		double	tuples,
		int	width,
		Cost	comparison_cost,
		int	sort_mem,
		double	limit_tuples
	)

Definition at line 2103 of file costsize.c.

 {
     Cost        startup_cost;
     Cost        run_cost;
  
     cost_tuplesort(&startup_cost, &run_cost,
                    tuples, width,
                    comparison_cost, sort_mem,
                    limit_tuples);
  
     if (!enable_sort)
         startup_cost += disable_cost;
  
     startup_cost += input_cost;
  
     path->rows = tuples;
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References cost_tuplesort(), disable_cost, enable_sort, Path::rows, Path::startup_cost, and Path::total_cost.

Referenced by adjust_foreign_grouping_path_cost(), choose_hashed_setop(), cost_append(), create_groupingsets_path(), create_merge_append_path(), create_sort_path(), create_unique_path(), initial_cost_mergejoin(), label_sort_with_costsize(), and plan_cluster_use_sort().

◆ cost_subplan()

void cost_subplan	(	PlannerInfo *	root,
		SubPlan *	subplan,
		Plan *	plan
	)

Definition at line 4414 of file costsize.c.

 {
     QualCost    sp_cost;
  
     /* Figure any cost for evaluating the testexpr */
     cost_qual_eval(&sp_cost,
                    make_ands_implicit((Expr *) subplan->testexpr),
                    root);
  
     if (subplan->useHashTable)
     {
         /*
          * If we are using a hash table for the subquery outputs, then the
          * cost of evaluating the query is a one-time cost.  We charge one
          * cpu_operator_cost per tuple for the work of loading the hashtable,
          * too.
          */
         sp_cost.startup += plan->total_cost +
             cpu_operator_cost * plan->plan_rows;
  
         /*
          * The per-tuple costs include the cost of evaluating the lefthand
          * expressions, plus the cost of probing the hashtable.  We already
          * accounted for the lefthand expressions as part of the testexpr, and
          * will also have counted one cpu_operator_cost for each comparison
          * operator.  That is probably too low for the probing cost, but it's
          * hard to make a better estimate, so live with it for now.
          */
     }
     else
     {
         /*
          * Otherwise we will be rescanning the subplan output on each
          * evaluation.  We need to estimate how much of the output we will
          * actually need to scan.  NOTE: this logic should agree with the
          * tuple_fraction estimates used by make_subplan() in
          * plan/subselect.c.
          */
         Cost        plan_run_cost = plan->total_cost - plan->startup_cost;
  
         if (subplan->subLinkType == EXISTS_SUBLINK)
         {
             /* we only need to fetch 1 tuple; clamp to avoid zero divide */
             sp_cost.per_tuple += plan_run_cost / clamp_row_est(plan->plan_rows);
         }
         else if (subplan->subLinkType == ALL_SUBLINK ||
                  subplan->subLinkType == ANY_SUBLINK)
         {
             /* assume we need 50% of the tuples */
             sp_cost.per_tuple += 0.50 * plan_run_cost;
             /* also charge a cpu_operator_cost per row examined */
             sp_cost.per_tuple += 0.50 * plan->plan_rows * cpu_operator_cost;
         }
         else
         {
             /* assume we need all tuples */
             sp_cost.per_tuple += plan_run_cost;
         }
  
         /*
          * Also account for subplan's startup cost. If the subplan is
          * uncorrelated or undirect correlated, AND its topmost node is one
          * that materializes its output, assume that we'll only need to pay
          * its startup cost once; otherwise assume we pay the startup cost
          * every time.
          */
         if (subplan->parParam == NIL &&
             ExecMaterializesOutput(nodeTag(plan)))
             sp_cost.startup += plan->startup_cost;
         else
             sp_cost.per_tuple += plan->startup_cost;
     }
  
     subplan->startup_cost = sp_cost.startup;
     subplan->per_call_cost = sp_cost.per_tuple;
 }

References ALL_SUBLINK, ANY_SUBLINK, clamp_row_est(), cost_qual_eval(), cpu_operator_cost, ExecMaterializesOutput(), EXISTS_SUBLINK, make_ands_implicit(), NIL, nodeTag, SubPlan::parParam, SubPlan::per_call_cost, QualCost::per_tuple, plan, root, QualCost::startup, SubPlan::startup_cost, SubPlan::subLinkType, SubPlan::testexpr, and SubPlan::useHashTable.

Referenced by build_subplan(), SS_make_initplan_from_plan(), and SS_process_ctes().

◆ cost_subqueryscan()

void cost_subqueryscan	(	SubqueryScanPath *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info,
		bool	trivial_pathtarget
	)

Definition at line 1430 of file costsize.c.

 {
     Cost        startup_cost;
     Cost        run_cost;
     List       *qpquals;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations that are subqueries */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_SUBQUERY);
  
     /*
      * We compute the rowcount estimate as the subplan's estimate times the
      * selectivity of relevant restriction clauses.  In simple cases this will
      * come out the same as baserel->rows; but when dealing with parallelized
      * paths we must do it like this to get the right answer.
      */
     if (param_info)
         qpquals = list_concat_copy(param_info->ppi_clauses,
                                    baserel->baserestrictinfo);
     else
         qpquals = baserel->baserestrictinfo;
  
     path->path.rows = clamp_row_est(path->subpath->rows *
                                     clauselist_selectivity(root,
                                                            qpquals,
                                                            0,
                                                            JOIN_INNER,
                                                            NULL));
  
     /*
      * Cost of path is cost of evaluating the subplan, plus cost of evaluating
      * any restriction clauses and tlist that will be attached to the
      * SubqueryScan node, plus cpu_tuple_cost to account for selection and
      * projection overhead.
      */
     path->path.startup_cost = path->subpath->startup_cost;
     path->path.total_cost = path->subpath->total_cost;
  
     /*
      * However, if there are no relevant restriction clauses and the
      * pathtarget is trivial, then we expect that setrefs.c will optimize away
      * the SubqueryScan plan node altogether, so we should just make its cost
      * and rowcount equal to the input path's.
      *
      * Note: there are some edge cases where createplan.c will apply a
      * different targetlist to the SubqueryScan node, thus falsifying our
      * current estimate of whether the target is trivial, and making the cost
      * estimate (though not the rowcount) wrong.  It does not seem worth the
      * extra complication to try to account for that exactly, especially since
      * that behavior falsifies other cost estimates as well.
      */
     if (qpquals == NIL && trivial_pathtarget)
         return;
  
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost = qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost = cpu_per_tuple * path->subpath->rows;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->path.pathtarget->cost.startup;
     run_cost += path->path.pathtarget->cost.per_tuple * path->path.rows;
  
     path->path.startup_cost += startup_cost;
     path->path.total_cost += startup_cost + run_cost;
 }

References Assert, RelOptInfo::baserestrictinfo, clamp_row_est(), clauselist_selectivity(), cpu_tuple_cost, get_restriction_qual_cost(), JOIN_INNER, list_concat_copy(), NIL, SubqueryScanPath::path, QualCost::per_tuple, ParamPathInfo::ppi_clauses, RelOptInfo::relid, root, Path::rows, RTE_SUBQUERY, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, SubqueryScanPath::subpath, and Path::total_cost.

Referenced by create_subqueryscan_path().

◆ cost_tablefuncscan()

void cost_tablefuncscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1571 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     RangeTblEntry *rte;
     QualCost    exprcost;
  
     /* Should only be applied to base relations that are functions */
     Assert(baserel->relid > 0);
     rte = planner_rt_fetch(baserel->relid, root);
     Assert(rte->rtekind == RTE_TABLEFUNC);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /*
      * Estimate costs of executing the table func expression(s).
      *
      * XXX in principle we ought to charge tuplestore spill costs if the
      * number of rows is large.  However, given how phony our rowcount
      * estimates for tablefuncs tend to be, there's not a lot of point in that
      * refinement right now.
      */
     cost_qual_eval_node(&exprcost, (Node *) rte->tablefunc, root);
  
     startup_cost += exprcost.startup + exprcost.per_tuple;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cost_qual_eval_node(), cpu_tuple_cost, get_restriction_qual_cost(), QualCost::per_tuple, planner_rt_fetch, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_TABLEFUNC, RangeTblEntry::rtekind, QualCost::startup, Path::startup_cost, RangeTblEntry::tablefunc, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_tablefuncscan_path().

◆ cost_tidrangescan()

void cost_tidrangescan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		List *	tidrangequals,
		ParamPathInfo *	param_info
	)

Definition at line 1339 of file costsize.c.

 {
     Selectivity selectivity;
     double      pages;
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     QualCost    tid_qual_cost;
     double      ntuples;
     double      nseqpages;
     double      spc_random_page_cost;
     double      spc_seq_page_cost;
  
     /* Should only be applied to base relations */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RELATION);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* Count how many tuples and pages we expect to scan */
     selectivity = clauselist_selectivity(root, tidrangequals, baserel->relid,
                                          JOIN_INNER, NULL);
     pages = ceil(selectivity * baserel->pages);
  
     if (pages <= 0.0)
         pages = 1.0;
  
     /*
      * The first page in a range requires a random seek, but each subsequent
      * page is just a normal sequential page read. NOTE: it's desirable for
      * TID Range Scans to cost more than the equivalent Sequential Scans,
      * because Seq Scans have some performance advantages such as scan
      * synchronization and parallelizability, and we'd prefer one of them to
      * be picked unless a TID Range Scan really is better.
      */
     ntuples = selectivity * baserel->tuples;
     nseqpages = pages - 1.0;
  
     /*
      * The TID qual expressions will be computed once, any other baserestrict
      * quals once per retrieved tuple.
      */
     cost_qual_eval(&tid_qual_cost, tidrangequals, root);
  
     /* fetch estimated page cost for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
                               &spc_random_page_cost,
                               &spc_seq_page_cost);
  
     /* disk costs; 1 random page and the remainder as seq pages */
     run_cost += spc_random_page_cost + spc_seq_page_cost * nseqpages;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     /*
      * XXX currently we assume TID quals are a subset of qpquals at this
      * point; they will be removed (if possible) when we create the plan, so
      * we subtract their cost from the total qpqual cost.  (If the TID quals
      * can't be removed, this is a mistake and we're going to underestimate
      * the CPU cost a bit.)
      */
     startup_cost += qpqual_cost.startup + tid_qual_cost.per_tuple;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple -
         tid_qual_cost.per_tuple;
     run_cost += cpu_per_tuple * ntuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, clauselist_selectivity(), cost_qual_eval(), cpu_tuple_cost, get_restriction_qual_cost(), get_tablespace_page_costs(), JOIN_INNER, RelOptInfo::pages, QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_tidrangescan_path().

◆ cost_tidscan()

void cost_tidscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		List *	tidquals,
		ParamPathInfo *	param_info
	)

Definition at line 1249 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
     QualCost    tid_qual_cost;
     double      ntuples;
     ListCell   *l;
     double      spc_random_page_cost;
  
     /* Should only be applied to base relations */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_RELATION);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /* Count how many tuples we expect to retrieve */
     ntuples = 0;
     foreach(l, tidquals)
     {
         RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
         Expr       *qual = rinfo->clause;
  
         if (IsA(qual, ScalarArrayOpExpr))
         {
             /* Each element of the array yields 1 tuple */
             ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) qual;
             Node       *arraynode = (Node *) lsecond(saop->args);
  
             ntuples += estimate_array_length(root, arraynode);
         }
         else if (IsA(qual, CurrentOfExpr))
         {
             /* CURRENT OF yields 1 tuple */
             ntuples++;
         }
         else
         {
             /* It's just CTID = something, count 1 tuple */
             ntuples++;
         }
     }
  
     /*
      * The TID qual expressions will be computed once, any other baserestrict
      * quals once per retrieved tuple.
      */
     cost_qual_eval(&tid_qual_cost, tidquals, root);
  
     /* fetch estimated page cost for tablespace containing table */
     get_tablespace_page_costs(baserel->reltablespace,
                               &spc_random_page_cost,
                               NULL);
  
     /* disk costs --- assume each tuple on a different page */
     run_cost += spc_random_page_cost * ntuples;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     /* XXX currently we assume TID quals are a subset of qpquals */
     startup_cost += qpqual_cost.startup + tid_qual_cost.per_tuple;
     cpu_per_tuple = cpu_tuple_cost + qpqual_cost.per_tuple -
         tid_qual_cost.per_tuple;
     run_cost += cpu_per_tuple * ntuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References ScalarArrayOpExpr::args, Assert, RestrictInfo::clause, cost_qual_eval(), cpu_tuple_cost, estimate_array_length(), get_restriction_qual_cost(), get_tablespace_page_costs(), IsA, lfirst_node, lsecond, QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, RelOptInfo::reltablespace, root, RelOptInfo::rows, Path::rows, RTE_RELATION, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, and Path::total_cost.

Referenced by create_tidscan_path().

◆ cost_valuesscan()

void cost_valuesscan	(	Path *	path,
		PlannerInfo *	root,
		RelOptInfo *	baserel,
		ParamPathInfo *	param_info
	)

Definition at line 1627 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     QualCost    qpqual_cost;
     Cost        cpu_per_tuple;
  
     /* Should only be applied to base relations that are values lists */
     Assert(baserel->relid > 0);
     Assert(baserel->rtekind == RTE_VALUES);
  
     /* Mark the path with the correct row estimate */
     if (param_info)
         path->rows = param_info->ppi_rows;
     else
         path->rows = baserel->rows;
  
     /*
      * For now, estimate list evaluation cost at one operator eval per list
      * (probably pretty bogus, but is it worth being smarter?)
      */
     cpu_per_tuple = cpu_operator_cost;
  
     /* Add scanning CPU costs */
     get_restriction_qual_cost(root, baserel, param_info, &qpqual_cost);
  
     startup_cost += qpqual_cost.startup;
     cpu_per_tuple += cpu_tuple_cost + qpqual_cost.per_tuple;
     run_cost += cpu_per_tuple * baserel->tuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->pathtarget->cost.startup;
     run_cost += path->pathtarget->cost.per_tuple * path->rows;
  
     path->startup_cost = startup_cost;
     path->total_cost = startup_cost + run_cost;
 }

References Assert, cpu_operator_cost, cpu_tuple_cost, get_restriction_qual_cost(), QualCost::per_tuple, ParamPathInfo::ppi_rows, RelOptInfo::relid, root, RelOptInfo::rows, Path::rows, RTE_VALUES, RelOptInfo::rtekind, QualCost::startup, Path::startup_cost, Path::total_cost, and RelOptInfo::tuples.

Referenced by create_valuesscan_path().

◆ cost_windowagg()

void cost_windowagg	(	Path *	path,
		PlannerInfo *	root,
		List *	windowFuncs,
		WindowClause *	winclause,
		Cost	input_startup_cost,
		Cost	input_total_cost,
		double	input_tuples
	)

Definition at line 3047 of file costsize.c.

 {
     Cost        startup_cost;
     Cost        total_cost;
     double      startup_tuples;
     int         numPartCols;
     int         numOrderCols;
     ListCell   *lc;
  
     numPartCols = list_length(winclause->partitionClause);
     numOrderCols = list_length(winclause->orderClause);
  
     startup_cost = input_startup_cost;
     total_cost = input_total_cost;
  
     /*
      * Window functions are assumed to cost their stated execution cost, plus
      * the cost of evaluating their input expressions, per tuple.  Since they
      * may in fact evaluate their inputs at multiple rows during each cycle,
      * this could be a drastic underestimate; but without a way to know how
      * many rows the window function will fetch, it's hard to do better.  In
      * any case, it's a good estimate for all the built-in window functions,
      * so we'll just do this for now.
      */
     foreach(lc, windowFuncs)
     {
         WindowFunc *wfunc = lfirst_node(WindowFunc, lc);
         Cost        wfunccost;
         QualCost    argcosts;
  
         argcosts.startup = argcosts.per_tuple = 0;
         add_function_cost(root, wfunc->winfnoid, (Node *) wfunc,
                           &argcosts);
         startup_cost += argcosts.startup;
         wfunccost = argcosts.per_tuple;
  
         /* also add the input expressions' cost to per-input-row costs */
         cost_qual_eval_node(&argcosts, (Node *) wfunc->args, root);
         startup_cost += argcosts.startup;
         wfunccost += argcosts.per_tuple;
  
         /*
          * Add the filter's cost to per-input-row costs.  XXX We should reduce
          * input expression costs according to filter selectivity.
          */
         cost_qual_eval_node(&argcosts, (Node *) wfunc->aggfilter, root);
         startup_cost += argcosts.startup;
         wfunccost += argcosts.per_tuple;
  
         total_cost += wfunccost * input_tuples;
     }
  
     /*
      * We also charge cpu_operator_cost per grouping column per tuple for
      * grouping comparisons, plus cpu_tuple_cost per tuple for general
      * overhead.
      *
      * XXX this neglects costs of spooling the data to disk when it overflows
      * work_mem.  Sooner or later that should get accounted for.
      */
     total_cost += cpu_operator_cost * (numPartCols + numOrderCols) * input_tuples;
     total_cost += cpu_tuple_cost * input_tuples;
  
     path->rows = input_tuples;
     path->startup_cost = startup_cost;
     path->total_cost = total_cost;
  
     /*
      * Also, take into account how many tuples we need to read from the
      * subnode in order to produce the first tuple from the WindowAgg.  To do
      * this we proportion the run cost (total cost not including startup cost)
      * over the estimated startup tuples.  We already included the startup
      * cost of the subnode, so we only need to do this when the estimated
      * startup tuples is above 1.0.
      */
     startup_tuples = get_windowclause_startup_tuples(root, winclause,
                                                      input_tuples);
  
     if (startup_tuples > 1.0)
         path->startup_cost += (total_cost - startup_cost) / input_tuples *
             (startup_tuples - 1.0);
 }

References add_function_cost(), WindowFunc::aggfilter, WindowFunc::args, cost_qual_eval_node(), cpu_operator_cost, cpu_tuple_cost, get_windowclause_startup_tuples(), lfirst_node, list_length(), WindowClause::orderClause, WindowClause::partitionClause, QualCost::per_tuple, root, Path::rows, QualCost::startup, Path::startup_cost, Path::total_cost, and WindowFunc::winfnoid.

Referenced by create_windowagg_path().

◆ final_cost_hashjoin()

void final_cost_hashjoin	(	PlannerInfo *	root,
		HashPath *	path,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra
	)

Definition at line 4160 of file costsize.c.

 {
     Path       *outer_path = path->jpath.outerjoinpath;
     Path       *inner_path = path->jpath.innerjoinpath;
     double      outer_path_rows = outer_path->rows;
     double      inner_path_rows = inner_path->rows;
     double      inner_path_rows_total = workspace->inner_rows_total;
     List       *hashclauses = path->path_hashclauses;
     Cost        startup_cost = workspace->startup_cost;
     Cost        run_cost = workspace->run_cost;
     int         numbuckets = workspace->numbuckets;
     int         numbatches = workspace->numbatches;
     Cost        cpu_per_tuple;
     QualCost    hash_qual_cost;
     QualCost    qp_qual_cost;
     double      hashjointuples;
     double      virtualbuckets;
     Selectivity innerbucketsize;
     Selectivity innermcvfreq;
     ListCell   *hcl;
  
     /* Mark the path with the correct row estimate */
     if (path->jpath.path.param_info)
         path->jpath.path.rows = path->jpath.path.param_info->ppi_rows;
     else
         path->jpath.path.rows = path->jpath.path.parent->rows;
  
     /* For partial paths, scale row estimate. */
     if (path->jpath.path.parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(&path->jpath.path);
  
         path->jpath.path.rows =
             clamp_row_est(path->jpath.path.rows / parallel_divisor);
     }
  
     /*
      * We could include disable_cost in the preliminary estimate, but that
      * would amount to optimizing for the case where the join method is
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_hashjoin)
         startup_cost += disable_cost;
  
     /* mark the path with estimated # of batches */
     path->num_batches = numbatches;
  
     /* store the total number of tuples (sum of partial row estimates) */
     path->inner_rows_total = inner_path_rows_total;
  
     /* and compute the number of "virtual" buckets in the whole join */
     virtualbuckets = (double) numbuckets * (double) numbatches;
  
     /*
      * Determine bucketsize fraction and MCV frequency for the inner relation.
      * We use the smallest bucketsize or MCV frequency estimated for any
      * individual hashclause; this is undoubtedly conservative.
      *
      * BUT: if inner relation has been unique-ified, we can assume it's good
      * for hashing.  This is important both because it's the right answer, and
      * because we avoid contaminating the cache with a value that's wrong for
      * non-unique-ified paths.
      */
     if (IsA(inner_path, UniquePath))
     {
         innerbucketsize = 1.0 / virtualbuckets;
         innermcvfreq = 0.0;
     }
     else
     {
         innerbucketsize = 1.0;
         innermcvfreq = 1.0;
         foreach(hcl, hashclauses)
         {
             RestrictInfo *restrictinfo = lfirst_node(RestrictInfo, hcl);
             Selectivity thisbucketsize;
             Selectivity thismcvfreq;
  
             /*
              * First we have to figure out which side of the hashjoin clause
              * is the inner side.
              *
              * Since we tend to visit the same clauses over and over when
              * planning a large query, we cache the bucket stats estimates in
              * the RestrictInfo node to avoid repeated lookups of statistics.
              */
             if (bms_is_subset(restrictinfo->right_relids,
                               inner_path->parent->relids))
             {
                 /* righthand side is inner */
                 thisbucketsize = restrictinfo->right_bucketsize;
                 if (thisbucketsize < 0)
                 {
                     /* not cached yet */
                     estimate_hash_bucket_stats(root,
                                                get_rightop(restrictinfo->clause),
                                                virtualbuckets,
                                                &restrictinfo->right_mcvfreq,
                                                &restrictinfo->right_bucketsize);
                     thisbucketsize = restrictinfo->right_bucketsize;
                 }
                 thismcvfreq = restrictinfo->right_mcvfreq;
             }
             else
             {
                 Assert(bms_is_subset(restrictinfo->left_relids,
                                      inner_path->parent->relids));
                 /* lefthand side is inner */
                 thisbucketsize = restrictinfo->left_bucketsize;
                 if (thisbucketsize < 0)
                 {
                     /* not cached yet */
                     estimate_hash_bucket_stats(root,
                                                get_leftop(restrictinfo->clause),
                                                virtualbuckets,
                                                &restrictinfo->left_mcvfreq,
                                                &restrictinfo->left_bucketsize);
                     thisbucketsize = restrictinfo->left_bucketsize;
                 }
                 thismcvfreq = restrictinfo->left_mcvfreq;
             }
  
             if (innerbucketsize > thisbucketsize)
                 innerbucketsize = thisbucketsize;
             if (innermcvfreq > thismcvfreq)
                 innermcvfreq = thismcvfreq;
         }
     }
  
     /*
      * If the bucket holding the inner MCV would exceed hash_mem, we don't
      * want to hash unless there is really no other alternative, so apply
      * disable_cost.  (The executor normally copes with excessive memory usage
      * by splitting batches, but obviously it cannot separate equal values
      * that way, so it will be unable to drive the batch size below hash_mem
      * when this is true.)
      */
     if (relation_byte_size(clamp_row_est(inner_path_rows * innermcvfreq),
                            inner_path->pathtarget->width) > get_hash_memory_limit())
         startup_cost += disable_cost;
  
     /*
      * Compute cost of the hashquals and qpquals (other restriction clauses)
      * separately.
      */
     cost_qual_eval(&hash_qual_cost, hashclauses, root);
     cost_qual_eval(&qp_qual_cost, path->jpath.joinrestrictinfo, root);
     qp_qual_cost.startup -= hash_qual_cost.startup;
     qp_qual_cost.per_tuple -= hash_qual_cost.per_tuple;
  
     /* CPU costs */
  
     if (path->jpath.jointype == JOIN_SEMI ||
         path->jpath.jointype == JOIN_ANTI ||
         extra->inner_unique)
     {
         double      outer_matched_rows;
         Selectivity inner_scan_frac;
  
         /*
          * With a SEMI or ANTI join, or if the innerrel is known unique, the
          * executor will stop after the first match.
          *
          * For an outer-rel row that has at least one match, we can expect the
          * bucket scan to stop after a fraction 1/(match_count+1) of the
          * bucket's rows, if the matches are evenly distributed.  Since they
          * probably aren't quite evenly distributed, we apply a fuzz factor of
          * 2.0 to that fraction.  (If we used a larger fuzz factor, we'd have
          * to clamp inner_scan_frac to at most 1.0; but since match_count is
          * at least 1, no such clamp is needed now.)
          */
         outer_matched_rows = rint(outer_path_rows * extra->semifactors.outer_match_frac);
         inner_scan_frac = 2.0 / (extra->semifactors.match_count + 1.0);
  
         startup_cost += hash_qual_cost.startup;
         run_cost += hash_qual_cost.per_tuple * outer_matched_rows *
             clamp_row_est(inner_path_rows * innerbucketsize * inner_scan_frac) * 0.5;
  
         /*
          * For unmatched outer-rel rows, the picture is quite a lot different.
          * In the first place, there is no reason to assume that these rows
          * preferentially hit heavily-populated buckets; instead assume they
          * are uncorrelated with the inner distribution and so they see an
          * average bucket size of inner_path_rows / virtualbuckets.  In the
          * second place, it seems likely that they will have few if any exact
          * hash-code matches and so very few of the tuples in the bucket will
          * actually require eval of the hash quals.  We don't have any good
          * way to estimate how many will, but for the moment assume that the
          * effective cost per bucket entry is one-tenth what it is for
          * matchable tuples.
          */
         run_cost += hash_qual_cost.per_tuple *
             (outer_path_rows - outer_matched_rows) *
             clamp_row_est(inner_path_rows / virtualbuckets) * 0.05;
  
         /* Get # of tuples that will pass the basic join */
         if (path->jpath.jointype == JOIN_ANTI)
             hashjointuples = outer_path_rows - outer_matched_rows;
         else
             hashjointuples = outer_matched_rows;
     }
     else
     {
         /*
          * The number of tuple comparisons needed is the number of outer
          * tuples times the typical number of tuples in a hash bucket, which
          * is the inner relation size times its bucketsize fraction.  At each
          * one, we need to evaluate the hashjoin quals.  But actually,
          * charging the full qual eval cost at each tuple is pessimistic,
          * since we don't evaluate the quals unless the hash values match
          * exactly.  For lack of a better idea, halve the cost estimate to
          * allow for that.
          */
         startup_cost += hash_qual_cost.startup;
         run_cost += hash_qual_cost.per_tuple * outer_path_rows *
             clamp_row_est(inner_path_rows * innerbucketsize) * 0.5;
  
         /*
          * Get approx # tuples passing the hashquals.  We use
          * approx_tuple_count here because we need an estimate done with
          * JOIN_INNER semantics.
          */
         hashjointuples = approx_tuple_count(root, &path->jpath, hashclauses);
     }
  
     /*
      * For each tuple that gets through the hashjoin proper, we charge
      * cpu_tuple_cost plus the cost of evaluating additional restriction
      * clauses that are to be applied at the join.  (This is pessimistic since
      * not all of the quals may get evaluated at each tuple.)
      */
     startup_cost += qp_qual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qp_qual_cost.per_tuple;
     run_cost += cpu_per_tuple * hashjointuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->jpath.path.pathtarget->cost.startup;
     run_cost += path->jpath.path.pathtarget->cost.per_tuple * path->jpath.path.rows;
  
     path->jpath.path.startup_cost = startup_cost;
     path->jpath.path.total_cost = startup_cost + run_cost;
 }

References approx_tuple_count(), Assert, bms_is_subset(), clamp_row_est(), RestrictInfo::clause, cost_qual_eval(), cpu_tuple_cost, disable_cost, enable_hashjoin, estimate_hash_bucket_stats(), get_hash_memory_limit(), get_leftop(), get_parallel_divisor(), get_rightop(), HashPath::inner_rows_total, JoinCostWorkspace::inner_rows_total, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, IsA, JOIN_ANTI, JOIN_SEMI, JoinPath::joinrestrictinfo, JoinPath::jointype, HashPath::jpath, lfirst_node, SemiAntiJoinFactors::match_count, HashPath::num_batches, JoinCostWorkspace::numbatches, JoinCostWorkspace::numbuckets, SemiAntiJoinFactors::outer_match_frac, JoinPath::outerjoinpath, HashPath::path_hashclauses, QualCost::per_tuple, relation_byte_size(), root, Path::rows, JoinCostWorkspace::run_cost, JoinPathExtraData::semifactors, QualCost::startup, and JoinCostWorkspace::startup_cost.

Referenced by create_hashjoin_path().

◆ final_cost_mergejoin()

void final_cost_mergejoin	(	PlannerInfo *	root,
		MergePath *	path,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra
	)

Definition at line 3724 of file costsize.c.

 {
     Path       *outer_path = path->jpath.outerjoinpath;
     Path       *inner_path = path->jpath.innerjoinpath;
     double      inner_path_rows = inner_path->rows;
     List       *mergeclauses = path->path_mergeclauses;
     List       *innersortkeys = path->innersortkeys;
     Cost        startup_cost = workspace->startup_cost;
     Cost        run_cost = workspace->run_cost;
     Cost        inner_run_cost = workspace->inner_run_cost;
     double      outer_rows = workspace->outer_rows;
     double      inner_rows = workspace->inner_rows;
     double      outer_skip_rows = workspace->outer_skip_rows;
     double      inner_skip_rows = workspace->inner_skip_rows;
     Cost        cpu_per_tuple,
                 bare_inner_cost,
                 mat_inner_cost;
     QualCost    merge_qual_cost;
     QualCost    qp_qual_cost;
     double      mergejointuples,
                 rescannedtuples;
     double      rescanratio;
  
     /* Protect some assumptions below that rowcounts aren't zero */
     if (inner_path_rows <= 0)
         inner_path_rows = 1;
  
     /* Mark the path with the correct row estimate */
     if (path->jpath.path.param_info)
         path->jpath.path.rows = path->jpath.path.param_info->ppi_rows;
     else
         path->jpath.path.rows = path->jpath.path.parent->rows;
  
     /* For partial paths, scale row estimate. */
     if (path->jpath.path.parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(&path->jpath.path);
  
         path->jpath.path.rows =
             clamp_row_est(path->jpath.path.rows / parallel_divisor);
     }
  
     /*
      * We could include disable_cost in the preliminary estimate, but that
      * would amount to optimizing for the case where the join method is
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_mergejoin)
         startup_cost += disable_cost;
  
     /*
      * Compute cost of the mergequals and qpquals (other restriction clauses)
      * separately.
      */
     cost_qual_eval(&merge_qual_cost, mergeclauses, root);
     cost_qual_eval(&qp_qual_cost, path->jpath.joinrestrictinfo, root);
     qp_qual_cost.startup -= merge_qual_cost.startup;
     qp_qual_cost.per_tuple -= merge_qual_cost.per_tuple;
  
     /*
      * With a SEMI or ANTI join, or if the innerrel is known unique, the
      * executor will stop scanning for matches after the first match.  When
      * all the joinclauses are merge clauses, this means we don't ever need to
      * back up the merge, and so we can skip mark/restore overhead.
      */
     if ((path->jpath.jointype == JOIN_SEMI ||
          path->jpath.jointype == JOIN_ANTI ||
          extra->inner_unique) &&
         (list_length(path->jpath.joinrestrictinfo) ==
          list_length(path->path_mergeclauses)))
         path->skip_mark_restore = true;
     else
         path->skip_mark_restore = false;
  
     /*
      * Get approx # tuples passing the mergequals.  We use approx_tuple_count
      * here because we need an estimate done with JOIN_INNER semantics.
      */
     mergejointuples = approx_tuple_count(root, &path->jpath, mergeclauses);
  
     /*
      * When there are equal merge keys in the outer relation, the mergejoin
      * must rescan any matching tuples in the inner relation. This means
      * re-fetching inner tuples; we have to estimate how often that happens.
      *
      * For regular inner and outer joins, the number of re-fetches can be
      * estimated approximately as size of merge join output minus size of
      * inner relation. Assume that the distinct key values are 1, 2, ..., and
      * denote the number of values of each key in the outer relation as m1,
      * m2, ...; in the inner relation, n1, n2, ...  Then we have
      *
      * size of join = m1 * n1 + m2 * n2 + ...
      *
      * number of rescanned tuples = (m1 - 1) * n1 + (m2 - 1) * n2 + ... = m1 *
      * n1 + m2 * n2 + ... - (n1 + n2 + ...) = size of join - size of inner
      * relation
      *
      * This equation works correctly for outer tuples having no inner match
      * (nk = 0), but not for inner tuples having no outer match (mk = 0); we
      * are effectively subtracting those from the number of rescanned tuples,
      * when we should not.  Can we do better without expensive selectivity
      * computations?
      *
      * The whole issue is moot if we are working from a unique-ified outer
      * input, or if we know we don't need to mark/restore at all.
      */
     if (IsA(outer_path, UniquePath) || path->skip_mark_restore)
         rescannedtuples = 0;
     else
     {
         rescannedtuples = mergejointuples - inner_path_rows;
         /* Must clamp because of possible underestimate */
         if (rescannedtuples < 0)
             rescannedtuples = 0;
     }
  
     /*
      * We'll inflate various costs this much to account for rescanning.  Note
      * that this is to be multiplied by something involving inner_rows, or
      * another number related to the portion of the inner rel we'll scan.
      */
     rescanratio = 1.0 + (rescannedtuples / inner_rows);
  
     /*
      * Decide whether we want to materialize the inner input to shield it from
      * mark/restore and performing re-fetches.  Our cost model for regular
      * re-fetches is that a re-fetch costs the same as an original fetch,
      * which is probably an overestimate; but on the other hand we ignore the
      * bookkeeping costs of mark/restore.  Not clear if it's worth developing
      * a more refined model.  So we just need to inflate the inner run cost by
      * rescanratio.
      */
     bare_inner_cost = inner_run_cost * rescanratio;
  
     /*
      * When we interpose a Material node the re-fetch cost is assumed to be
      * just cpu_operator_cost per tuple, independently of the underlying
      * plan's cost; and we charge an extra cpu_operator_cost per original
      * fetch as well.  Note that we're assuming the materialize node will
      * never spill to disk, since it only has to remember tuples back to the
      * last mark.  (If there are a huge number of duplicates, our other cost
      * factors will make the path so expensive that it probably won't get
      * chosen anyway.)  So we don't use cost_rescan here.
      *
      * Note: keep this estimate in sync with create_mergejoin_plan's labeling
      * of the generated Material node.
      */
     mat_inner_cost = inner_run_cost +
         cpu_operator_cost * inner_rows * rescanratio;
  
     /*
      * If we don't need mark/restore at all, we don't need materialization.
      */
     if (path->skip_mark_restore)
         path->materialize_inner = false;
  
     /*
      * Prefer materializing if it looks cheaper, unless the user has asked to
      * suppress materialization.
      */
     else if (enable_material && mat_inner_cost < bare_inner_cost)
         path->materialize_inner = true;
  
     /*
      * Even if materializing doesn't look cheaper, we *must* do it if the
      * inner path is to be used directly (without sorting) and it doesn't
      * support mark/restore.
      *
      * Since the inner side must be ordered, and only Sorts and IndexScans can
      * create order to begin with, and they both support mark/restore, you
      * might think there's no problem --- but you'd be wrong.  Nestloop and
      * merge joins can *preserve* the order of their inputs, so they can be
      * selected as the input of a mergejoin, and they don't support
      * mark/restore at present.
      *
      * We don't test the value of enable_material here, because
      * materialization is required for correctness in this case, and turning
      * it off does not entitle us to deliver an invalid plan.
      */
     else if (innersortkeys == NIL &&
              !ExecSupportsMarkRestore(inner_path))
         path->materialize_inner = true;
  
     /*
      * Also, force materializing if the inner path is to be sorted and the
      * sort is expected to spill to disk.  This is because the final merge
      * pass can be done on-the-fly if it doesn't have to support mark/restore.
      * We don't try to adjust the cost estimates for this consideration,
      * though.
      *
      * Since materialization is a performance optimization in this case,
      * rather than necessary for correctness, we skip it if enable_material is
      * off.
      */
     else if (enable_material && innersortkeys != NIL &&
              relation_byte_size(inner_path_rows,
                                 inner_path->pathtarget->width) >
              (work_mem * 1024L))
         path->materialize_inner = true;
     else
         path->materialize_inner = false;
  
     /* Charge the right incremental cost for the chosen case */
     if (path->materialize_inner)
         run_cost += mat_inner_cost;
     else
         run_cost += bare_inner_cost;
  
     /* CPU costs */
  
     /*
      * The number of tuple comparisons needed is approximately number of outer
      * rows plus number of inner rows plus number of rescanned tuples (can we
      * refine this?).  At each one, we need to evaluate the mergejoin quals.
      */
     startup_cost += merge_qual_cost.startup;
     startup_cost += merge_qual_cost.per_tuple *
         (outer_skip_rows + inner_skip_rows * rescanratio);
     run_cost += merge_qual_cost.per_tuple *
         ((outer_rows - outer_skip_rows) +
          (inner_rows - inner_skip_rows) * rescanratio);
  
     /*
      * For each tuple that gets through the mergejoin proper, we charge
      * cpu_tuple_cost plus the cost of evaluating additional restriction
      * clauses that are to be applied at the join.  (This is pessimistic since
      * not all of the quals may get evaluated at each tuple.)
      *
      * Note: we could adjust for SEMI/ANTI joins skipping some qual
      * evaluations here, but it's probably not worth the trouble.
      */
     startup_cost += qp_qual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + qp_qual_cost.per_tuple;
     run_cost += cpu_per_tuple * mergejointuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->jpath.path.pathtarget->cost.startup;
     run_cost += path->jpath.path.pathtarget->cost.per_tuple * path->jpath.path.rows;
  
     path->jpath.path.startup_cost = startup_cost;
     path->jpath.path.total_cost = startup_cost + run_cost;
 }

References approx_tuple_count(), clamp_row_est(), cost_qual_eval(), cpu_operator_cost, cpu_tuple_cost, disable_cost, enable_material, enable_mergejoin, ExecSupportsMarkRestore(), get_parallel_divisor(), if(), JoinCostWorkspace::inner_rows, JoinCostWorkspace::inner_run_cost, JoinCostWorkspace::inner_skip_rows, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, MergePath::innersortkeys, IsA, JOIN_ANTI, JOIN_SEMI, JoinPath::joinrestrictinfo, JoinPath::jointype, MergePath::jpath, list_length(), MergePath::materialize_inner, NIL, JoinCostWorkspace::outer_rows, JoinCostWorkspace::outer_skip_rows, JoinPath::outerjoinpath, MergePath::path_mergeclauses, QualCost::per_tuple, relation_byte_size(), root, Path::rows, JoinCostWorkspace::run_cost, MergePath::skip_mark_restore, QualCost::startup, JoinCostWorkspace::startup_cost, and work_mem.

Referenced by create_mergejoin_path().

◆ final_cost_nestloop()

void final_cost_nestloop	(	PlannerInfo *	root,
		NestPath *	path,
		JoinCostWorkspace *	workspace,
		JoinPathExtraData *	extra
	)

Definition at line 3287 of file costsize.c.

 {
     Path       *outer_path = path->jpath.outerjoinpath;
     Path       *inner_path = path->jpath.innerjoinpath;
     double      outer_path_rows = outer_path->rows;
     double      inner_path_rows = inner_path->rows;
     Cost        startup_cost = workspace->startup_cost;
     Cost        run_cost = workspace->run_cost;
     Cost        cpu_per_tuple;
     QualCost    restrict_qual_cost;
     double      ntuples;
  
     /* Protect some assumptions below that rowcounts aren't zero */
     if (outer_path_rows <= 0)
         outer_path_rows = 1;
     if (inner_path_rows <= 0)
         inner_path_rows = 1;
     /* Mark the path with the correct row estimate */
     if (path->jpath.path.param_info)
         path->jpath.path.rows = path->jpath.path.param_info->ppi_rows;
     else
         path->jpath.path.rows = path->jpath.path.parent->rows;
  
     /* For partial paths, scale row estimate. */
     if (path->jpath.path.parallel_workers > 0)
     {
         double      parallel_divisor = get_parallel_divisor(&path->jpath.path);
  
         path->jpath.path.rows =
             clamp_row_est(path->jpath.path.rows / parallel_divisor);
     }
  
     /*
      * We could include disable_cost in the preliminary estimate, but that
      * would amount to optimizing for the case where the join method is
      * disabled, which doesn't seem like the way to bet.
      */
     if (!enable_nestloop)
         startup_cost += disable_cost;
  
     /* cost of inner-relation source data (we already dealt with outer rel) */
  
     if (path->jpath.jointype == JOIN_SEMI || path->jpath.jointype == JOIN_ANTI ||
         extra->inner_unique)
     {
         /*
          * With a SEMI or ANTI join, or if the innerrel is known unique, the
          * executor will stop after the first match.
          */
         Cost        inner_run_cost = workspace->inner_run_cost;
         Cost        inner_rescan_run_cost = workspace->inner_rescan_run_cost;
         double      outer_matched_rows;
         double      outer_unmatched_rows;
         Selectivity inner_scan_frac;
  
         /*
          * For an outer-rel row that has at least one match, we can expect the
          * inner scan to stop after a fraction 1/(match_count+1) of the inner
          * rows, if the matches are evenly distributed.  Since they probably
          * aren't quite evenly distributed, we apply a fuzz factor of 2.0 to
          * that fraction.  (If we used a larger fuzz factor, we'd have to
          * clamp inner_scan_frac to at most 1.0; but since match_count is at
          * least 1, no such clamp is needed now.)
          */
         outer_matched_rows = rint(outer_path_rows * extra->semifactors.outer_match_frac);
         outer_unmatched_rows = outer_path_rows - outer_matched_rows;
         inner_scan_frac = 2.0 / (extra->semifactors.match_count + 1.0);
  
         /*
          * Compute number of tuples processed (not number emitted!).  First,
          * account for successfully-matched outer rows.
          */
         ntuples = outer_matched_rows * inner_path_rows * inner_scan_frac;
  
         /*
          * Now we need to estimate the actual costs of scanning the inner
          * relation, which may be quite a bit less than N times inner_run_cost
          * due to early scan stops.  We consider two cases.  If the inner path
          * is an indexscan using all the joinquals as indexquals, then an
          * unmatched outer row results in an indexscan returning no rows,
          * which is probably quite cheap.  Otherwise, the executor will have
          * to scan the whole inner rel for an unmatched row; not so cheap.
          */
         if (has_indexed_join_quals(path))
         {
             /*
              * Successfully-matched outer rows will only require scanning
              * inner_scan_frac of the inner relation.  In this case, we don't
              * need to charge the full inner_run_cost even when that's more
              * than inner_rescan_run_cost, because we can assume that none of
              * the inner scans ever scan the whole inner relation.  So it's
              * okay to assume that all the inner scan executions can be
              * fractions of the full cost, even if materialization is reducing
              * the rescan cost.  At this writing, it's impossible to get here
              * for a materialized inner scan, so inner_run_cost and
              * inner_rescan_run_cost will be the same anyway; but just in
              * case, use inner_run_cost for the first matched tuple and
              * inner_rescan_run_cost for additional ones.
              */
             run_cost += inner_run_cost * inner_scan_frac;
             if (outer_matched_rows > 1)
                 run_cost += (outer_matched_rows - 1) * inner_rescan_run_cost * inner_scan_frac;
  
             /*
              * Add the cost of inner-scan executions for unmatched outer rows.
              * We estimate this as the same cost as returning the first tuple
              * of a nonempty scan.  We consider that these are all rescans,
              * since we used inner_run_cost once already.
              */
             run_cost += outer_unmatched_rows *
                 inner_rescan_run_cost / inner_path_rows;
  
             /*
              * We won't be evaluating any quals at all for unmatched rows, so
              * don't add them to ntuples.
              */
         }
         else
         {
             /*
              * Here, a complicating factor is that rescans may be cheaper than
              * first scans.  If we never scan all the way to the end of the
              * inner rel, it might be (depending on the plan type) that we'd
              * never pay the whole inner first-scan run cost.  However it is
              * difficult to estimate whether that will happen (and it could
              * not happen if there are any unmatched outer rows!), so be
              * conservative and always charge the whole first-scan cost once.
              * We consider this charge to correspond to the first unmatched
              * outer row, unless there isn't one in our estimate, in which
              * case blame it on the first matched row.
              */
  
             /* First, count all unmatched join tuples as being processed */
             ntuples += outer_unmatched_rows * inner_path_rows;
  
             /* Now add the forced full scan, and decrement appropriate count */
             run_cost += inner_run_cost;
             if (outer_unmatched_rows >= 1)
                 outer_unmatched_rows -= 1;
             else
                 outer_matched_rows -= 1;
  
             /* Add inner run cost for additional outer tuples having matches */
             if (outer_matched_rows > 0)
                 run_cost += outer_matched_rows * inner_rescan_run_cost * inner_scan_frac;
  
             /* Add inner run cost for additional unmatched outer tuples */
             if (outer_unmatched_rows > 0)
                 run_cost += outer_unmatched_rows * inner_rescan_run_cost;
         }
     }
     else
     {
         /* Normal-case source costs were included in preliminary estimate */
  
         /* Compute number of tuples processed (not number emitted!) */
         ntuples = outer_path_rows * inner_path_rows;
     }
  
     /* CPU costs */
     cost_qual_eval(&restrict_qual_cost, path->jpath.joinrestrictinfo, root);
     startup_cost += restrict_qual_cost.startup;
     cpu_per_tuple = cpu_tuple_cost + restrict_qual_cost.per_tuple;
     run_cost += cpu_per_tuple * ntuples;
  
     /* tlist eval costs are paid per output row, not per tuple scanned */
     startup_cost += path->jpath.path.pathtarget->cost.startup;
     run_cost += path->jpath.path.pathtarget->cost.per_tuple * path->jpath.path.rows;
  
     path->jpath.path.startup_cost = startup_cost;
     path->jpath.path.total_cost = startup_cost + run_cost;
 }

References clamp_row_est(), cost_qual_eval(), cpu_tuple_cost, disable_cost, enable_nestloop, get_parallel_divisor(), has_indexed_join_quals(), JoinCostWorkspace::inner_rescan_run_cost, JoinCostWorkspace::inner_run_cost, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, JOIN_ANTI, JOIN_SEMI, JoinPath::joinrestrictinfo, JoinPath::jointype, NestPath::jpath, SemiAntiJoinFactors::match_count, SemiAntiJoinFactors::outer_match_frac, JoinPath::outerjoinpath, QualCost::per_tuple, root, Path::rows, JoinCostWorkspace::run_cost, JoinPathExtraData::semifactors, QualCost::startup, and JoinCostWorkspace::startup_cost.

Referenced by create_nestloop_path().

◆ get_parameterized_baserel_size()

double get_parameterized_baserel_size	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	param_clauses
	)

Definition at line 5243 of file costsize.c.

 {
     List       *allclauses;
     double      nrows;
  
     /*
      * Estimate the number of rows returned by the parameterized scan, knowing
      * that it will apply all the extra join clauses as well as the rel's own
      * restriction clauses.  Note that we force the clauses to be treated as
      * non-join clauses during selectivity estimation.
      */
     allclauses = list_concat_copy(param_clauses, rel->baserestrictinfo);
     nrows = rel->tuples *
         clauselist_selectivity(root,
                                allclauses,
                                rel->relid,  /* do not use 0! */
                                JOIN_INNER,
                                NULL);
     nrows = clamp_row_est(nrows);
     /* For safety, make sure result is not more than the base estimate */
     if (nrows > rel->rows)
         nrows = rel->rows;
     return nrows;
 }

References RelOptInfo::baserestrictinfo, clamp_row_est(), clauselist_selectivity(), JOIN_INNER, list_concat_copy(), RelOptInfo::relid, root, RelOptInfo::rows, and RelOptInfo::tuples.

Referenced by get_baserel_parampathinfo().

◆ get_parameterized_joinrel_size()

double get_parameterized_joinrel_size	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	outer_path,
		Path *	inner_path,
		SpecialJoinInfo *	sjinfo,
		List *	restrict_clauses
	)

Definition at line 5324 of file costsize.c.

 {
     double      nrows;
  
     /*
      * Estimate the number of rows returned by the parameterized join as the
      * sizes of the input paths times the selectivity of the clauses that have
      * ended up at this join node.
      *
      * As with set_joinrel_size_estimates, the rowcount estimate could depend
      * on the pair of input paths provided, though ideally we'd get the same
      * estimate for any pair with the same parameterization.
      */
     nrows = calc_joinrel_size_estimate(root,
                                        rel,
                                        outer_path->parent,
                                        inner_path->parent,
                                        outer_path->rows,
                                        inner_path->rows,
                                        sjinfo,
                                        restrict_clauses);
     /* For safety, make sure result is not more than the base estimate */
     if (nrows > rel->rows)
         nrows = rel->rows;
     return nrows;
 }

References calc_joinrel_size_estimate(), root, RelOptInfo::rows, and Path::rows.

Referenced by get_joinrel_parampathinfo().

◆ index_pages_fetched()

double index_pages_fetched	(	double	tuples_fetched,
		BlockNumber	pages,
		double	index_pages,
		PlannerInfo *	root
	)

Definition at line 898 of file costsize.c.

 {
     double      pages_fetched;
     double      total_pages;
     double      T,
                 b;
  
     /* T is # pages in table, but don't allow it to be zero */
     T = (pages > 1) ? (double) pages : 1.0;
  
     /* Compute number of pages assumed to be competing for cache space */
     total_pages = root->total_table_pages + index_pages;
     total_pages = Max(total_pages, 1.0);
     Assert(T <= total_pages);
  
     /* b is pro-rated share of effective_cache_size */
     b = (double) effective_cache_size * T / total_pages;
  
     /* force it positive and integral */
     if (b <= 1.0)
         b = 1.0;
     else
         b = ceil(b);
  
     /* This part is the Mackert and Lohman formula */
     if (T <= b)
     {
         pages_fetched =
             (2.0 * T * tuples_fetched) / (2.0 * T + tuples_fetched);
         if (pages_fetched >= T)
             pages_fetched = T;
         else
             pages_fetched = ceil(pages_fetched);
     }
     else
     {
         double      lim;
  
         lim = (2.0 * T * b) / (2.0 * T - b);
         if (tuples_fetched <= lim)
         {
             pages_fetched =
                 (2.0 * T * tuples_fetched) / (2.0 * T + tuples_fetched);
         }
         else
         {
             pages_fetched =
                 b + (tuples_fetched - lim) * (T - b) / T;
         }
         pages_fetched = ceil(pages_fetched);
     }
     return pages_fetched;
 }

References Assert, b, effective_cache_size, Max, root, and T.

Referenced by compute_bitmap_pages(), cost_index(), genericcostestimate(), and gincostestimate().

◆ initial_cost_hashjoin()

void initial_cost_hashjoin	(	PlannerInfo *	root,
		JoinCostWorkspace *	workspace,
		JoinType	jointype,
		List *	hashclauses,
		Path *	outer_path,
		Path *	inner_path,
		JoinPathExtraData *	extra,
		bool	parallel_hash
	)

Definition at line 4052 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     double      outer_path_rows = outer_path->rows;
     double      inner_path_rows = inner_path->rows;
     double      inner_path_rows_total = inner_path_rows;
     int         num_hashclauses = list_length(hashclauses);
     int         numbuckets;
     int         numbatches;
     int         num_skew_mcvs;
     size_t      space_allowed;  /* unused */
  
     /* cost of source data */
     startup_cost += outer_path->startup_cost;
     run_cost += outer_path->total_cost - outer_path->startup_cost;
     startup_cost += inner_path->total_cost;
  
     /*
      * Cost of computing hash function: must do it once per input tuple. We
      * charge one cpu_operator_cost for each column's hash function.  Also,
      * tack on one cpu_tuple_cost per inner row, to model the costs of
      * inserting the row into the hashtable.
      *
      * XXX when a hashclause is more complex than a single operator, we really
      * should charge the extra eval costs of the left or right side, as
      * appropriate, here.  This seems more work than it's worth at the moment.
      */
     startup_cost += (cpu_operator_cost * num_hashclauses + cpu_tuple_cost)
         * inner_path_rows;
     run_cost += cpu_operator_cost * num_hashclauses * outer_path_rows;
  
     /*
      * If this is a parallel hash build, then the value we have for
      * inner_rows_total currently refers only to the rows returned by each
      * participant.  For shared hash table size estimation, we need the total
      * number, so we need to undo the division.
      */
     if (parallel_hash)
         inner_path_rows_total *= get_parallel_divisor(inner_path);
  
     /*
      * Get hash table size that executor would use for inner relation.
      *
      * XXX for the moment, always assume that skew optimization will be
      * performed.  As long as SKEW_HASH_MEM_PERCENT is small, it's not worth
      * trying to determine that for sure.
      *
      * XXX at some point it might be interesting to try to account for skew
      * optimization in the cost estimate, but for now, we don't.
      */
     ExecChooseHashTableSize(inner_path_rows_total,
                             inner_path->pathtarget->width,
                             true,   /* useskew */
                             parallel_hash,  /* try_combined_hash_mem */
                             outer_path->parallel_workers,
                             &space_allowed,
                             &numbuckets,
                             &numbatches,
                             &num_skew_mcvs);
  
     /*
      * If inner relation is too big then we will need to "batch" the join,
      * which implies writing and reading most of the tuples to disk an extra
      * time.  Charge seq_page_cost per page, since the I/O should be nice and
      * sequential.  Writing the inner rel counts as startup cost, all the rest
      * as run cost.
      */
     if (numbatches > 1)
     {
         double      outerpages = page_size(outer_path_rows,
                                            outer_path->pathtarget->width);
         double      innerpages = page_size(inner_path_rows,
                                            inner_path->pathtarget->width);
  
         startup_cost += seq_page_cost * innerpages;
         run_cost += seq_page_cost * (innerpages + 2 * outerpages);
     }
  
     /* CPU costs left for later */
  
     /* Public result fields */
     workspace->startup_cost = startup_cost;
     workspace->total_cost = startup_cost + run_cost;
     /* Save private data for final_cost_hashjoin */
     workspace->run_cost = run_cost;
     workspace->numbuckets = numbuckets;
     workspace->numbatches = numbatches;
     workspace->inner_rows_total = inner_path_rows_total;
 }

References cpu_operator_cost, cpu_tuple_cost, ExecChooseHashTableSize(), get_parallel_divisor(), JoinCostWorkspace::inner_rows_total, list_length(), JoinCostWorkspace::numbatches, JoinCostWorkspace::numbuckets, page_size(), Path::parallel_workers, Path::rows, JoinCostWorkspace::run_cost, seq_page_cost, Path::startup_cost, JoinCostWorkspace::startup_cost, Path::total_cost, and JoinCostWorkspace::total_cost.

Referenced by try_hashjoin_path(), and try_partial_hashjoin_path().

◆ initial_cost_mergejoin()

void initial_cost_mergejoin	(	PlannerInfo *	root,
		JoinCostWorkspace *	workspace,
		JoinType	jointype,
		List *	mergeclauses,
		Path *	outer_path,
		Path *	inner_path,
		List *	outersortkeys,
		List *	innersortkeys,
		JoinPathExtraData *	extra
	)

Definition at line 3493 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     double      outer_path_rows = outer_path->rows;
     double      inner_path_rows = inner_path->rows;
     Cost        inner_run_cost;
     double      outer_rows,
                 inner_rows,
                 outer_skip_rows,
                 inner_skip_rows;
     Selectivity outerstartsel,
                 outerendsel,
                 innerstartsel,
                 innerendsel;
     Path        sort_path;      /* dummy for result of cost_sort */
  
     /* Protect some assumptions below that rowcounts aren't zero */
     if (outer_path_rows <= 0)
         outer_path_rows = 1;
     if (inner_path_rows <= 0)
         inner_path_rows = 1;
  
     /*
      * A merge join will stop as soon as it exhausts either input stream
      * (unless it's an outer join, in which case the outer side has to be
      * scanned all the way anyway).  Estimate fraction of the left and right
      * inputs that will actually need to be scanned.  Likewise, we can
      * estimate the number of rows that will be skipped before the first join
      * pair is found, which should be factored into startup cost. We use only
      * the first (most significant) merge clause for this purpose. Since
      * mergejoinscansel() is a fairly expensive computation, we cache the
      * results in the merge clause RestrictInfo.
      */
     if (mergeclauses && jointype != JOIN_FULL)
     {
         RestrictInfo *firstclause = (RestrictInfo *) linitial(mergeclauses);
         List       *opathkeys;
         List       *ipathkeys;
         PathKey    *opathkey;
         PathKey    *ipathkey;
         MergeScanSelCache *cache;
  
         /* Get the input pathkeys to determine the sort-order details */
         opathkeys = outersortkeys ? outersortkeys : outer_path->pathkeys;
         ipathkeys = innersortkeys ? innersortkeys : inner_path->pathkeys;
         Assert(opathkeys);
         Assert(ipathkeys);
         opathkey = (PathKey *) linitial(opathkeys);
         ipathkey = (PathKey *) linitial(ipathkeys);
         /* debugging check */
         if (opathkey->pk_opfamily != ipathkey->pk_opfamily ||
             opathkey->pk_eclass->ec_collation != ipathkey->pk_eclass->ec_collation ||
             opathkey->pk_strategy != ipathkey->pk_strategy ||
             opathkey->pk_nulls_first != ipathkey->pk_nulls_first)
             elog(ERROR, "left and right pathkeys do not match in mergejoin");
  
         /* Get the selectivity with caching */
         cache = cached_scansel(root, firstclause, opathkey);
  
         if (bms_is_subset(firstclause->left_relids,
                           outer_path->parent->relids))
         {
             /* left side of clause is outer */
             outerstartsel = cache->leftstartsel;
             outerendsel = cache->leftendsel;
             innerstartsel = cache->rightstartsel;
             innerendsel = cache->rightendsel;
         }
         else
         {
             /* left side of clause is inner */
             outerstartsel = cache->rightstartsel;
             outerendsel = cache->rightendsel;
             innerstartsel = cache->leftstartsel;
             innerendsel = cache->leftendsel;
         }
         if (jointype == JOIN_LEFT ||
             jointype == JOIN_ANTI)
         {
             outerstartsel = 0.0;
             outerendsel = 1.0;
         }
         else if (jointype == JOIN_RIGHT ||
                  jointype == JOIN_RIGHT_ANTI)
         {
             innerstartsel = 0.0;
             innerendsel = 1.0;
         }
     }
     else
     {
         /* cope with clauseless or full mergejoin */
         outerstartsel = innerstartsel = 0.0;
         outerendsel = innerendsel = 1.0;
     }
  
     /*
      * Convert selectivities to row counts.  We force outer_rows and
      * inner_rows to be at least 1, but the skip_rows estimates can be zero.
      */
     outer_skip_rows = rint(outer_path_rows * outerstartsel);
     inner_skip_rows = rint(inner_path_rows * innerstartsel);
     outer_rows = clamp_row_est(outer_path_rows * outerendsel);
     inner_rows = clamp_row_est(inner_path_rows * innerendsel);
  
     Assert(outer_skip_rows <= outer_rows);
     Assert(inner_skip_rows <= inner_rows);
  
     /*
      * Readjust scan selectivities to account for above rounding.  This is
      * normally an insignificant effect, but when there are only a few rows in
      * the inputs, failing to do this makes for a large percentage error.
      */
     outerstartsel = outer_skip_rows / outer_path_rows;
     innerstartsel = inner_skip_rows / inner_path_rows;
     outerendsel = outer_rows / outer_path_rows;
     innerendsel = inner_rows / inner_path_rows;
  
     Assert(outerstartsel <= outerendsel);
     Assert(innerstartsel <= innerendsel);
  
     /* cost of source data */
  
     if (outersortkeys)          /* do we need to sort outer? */
     {
         cost_sort(&sort_path,
                   root,
                   outersortkeys,
                   outer_path->total_cost,
                   outer_path_rows,
                   outer_path->pathtarget->width,
                   0.0,
                   work_mem,
                   -1.0);
         startup_cost += sort_path.startup_cost;
         startup_cost += (sort_path.total_cost - sort_path.startup_cost)
             * outerstartsel;
         run_cost += (sort_path.total_cost - sort_path.startup_cost)
             * (outerendsel - outerstartsel);
     }
     else
     {
         startup_cost += outer_path->startup_cost;
         startup_cost += (outer_path->total_cost - outer_path->startup_cost)
             * outerstartsel;
         run_cost += (outer_path->total_cost - outer_path->startup_cost)
             * (outerendsel - outerstartsel);
     }
  
     if (innersortkeys)          /* do we need to sort inner? */
     {
         cost_sort(&sort_path,
                   root,
                   innersortkeys,
                   inner_path->total_cost,
                   inner_path_rows,
                   inner_path->pathtarget->width,
                   0.0,
                   work_mem,
                   -1.0);
         startup_cost += sort_path.startup_cost;
         startup_cost += (sort_path.total_cost - sort_path.startup_cost)
             * innerstartsel;
         inner_run_cost = (sort_path.total_cost - sort_path.startup_cost)
             * (innerendsel - innerstartsel);
     }
     else
     {
         startup_cost += inner_path->startup_cost;
         startup_cost += (inner_path->total_cost - inner_path->startup_cost)
             * innerstartsel;
         inner_run_cost = (inner_path->total_cost - inner_path->startup_cost)
             * (innerendsel - innerstartsel);
     }
  
     /*
      * We can't yet determine whether rescanning occurs, or whether
      * materialization of the inner input should be done.  The minimum
      * possible inner input cost, regardless of rescan and materialization
      * considerations, is inner_run_cost.  We include that in
      * workspace->total_cost, but not yet in run_cost.
      */
  
     /* CPU costs left for later */
  
     /* Public result fields */
     workspace->startup_cost = startup_cost;
     workspace->total_cost = startup_cost + run_cost + inner_run_cost;
     /* Save private data for final_cost_mergejoin */
     workspace->run_cost = run_cost;
     workspace->inner_run_cost = inner_run_cost;
     workspace->outer_rows = outer_rows;
     workspace->inner_rows = inner_rows;
     workspace->outer_skip_rows = outer_skip_rows;
     workspace->inner_skip_rows = inner_skip_rows;
 }

Referenced by try_mergejoin_path(), and try_partial_mergejoin_path().

◆ initial_cost_nestloop()

void initial_cost_nestloop	(	PlannerInfo *	root,
		JoinCostWorkspace *	workspace,
		JoinType	jointype,
		Path *	outer_path,
		Path *	inner_path,
		JoinPathExtraData *	extra
	)

Definition at line 3212 of file costsize.c.

 {
     Cost        startup_cost = 0;
     Cost        run_cost = 0;
     double      outer_path_rows = outer_path->rows;
     Cost        inner_rescan_start_cost;
     Cost        inner_rescan_total_cost;
     Cost        inner_run_cost;
     Cost        inner_rescan_run_cost;
  
     /* estimate costs to rescan the inner relation */
     cost_rescan(root, inner_path,
                 &inner_rescan_start_cost,
                 &inner_rescan_total_cost);
  
     /* cost of source data */
  
     /*
      * NOTE: clearly, we must pay both outer and inner paths' startup_cost
      * before we can start returning tuples, so the join's startup cost is
      * their sum.  We'll also pay the inner path's rescan startup cost
      * multiple times.
      */
     startup_cost += outer_path->startup_cost + inner_path->startup_cost;
     run_cost += outer_path->total_cost - outer_path->startup_cost;
     if (outer_path_rows > 1)
         run_cost += (outer_path_rows - 1) * inner_rescan_start_cost;
  
     inner_run_cost = inner_path->total_cost - inner_path->startup_cost;
     inner_rescan_run_cost = inner_rescan_total_cost - inner_rescan_start_cost;
  
     if (jointype == JOIN_SEMI || jointype == JOIN_ANTI ||
         extra->inner_unique)
     {
         /*
          * With a SEMI or ANTI join, or if the innerrel is known unique, the
          * executor will stop after the first match.
          *
          * Getting decent estimates requires inspection of the join quals,
          * which we choose to postpone to final_cost_nestloop.
          */
  
         /* Save private data for final_cost_nestloop */
         workspace->inner_run_cost = inner_run_cost;
         workspace->inner_rescan_run_cost = inner_rescan_run_cost;
     }
     else
     {
         /* Normal case; we'll scan whole input rel for each outer row */
         run_cost += inner_run_cost;
         if (outer_path_rows > 1)
             run_cost += (outer_path_rows - 1) * inner_rescan_run_cost;
     }
  
     /* CPU costs left for later */
  
     /* Public result fields */
     workspace->startup_cost = startup_cost;
     workspace->total_cost = startup_cost + run_cost;
     /* Save private data for final_cost_nestloop */
     workspace->run_cost = run_cost;
 }

References cost_rescan(), JoinCostWorkspace::inner_rescan_run_cost, JoinCostWorkspace::inner_run_cost, JoinPathExtraData::inner_unique, JOIN_ANTI, JOIN_SEMI, root, Path::rows, JoinCostWorkspace::run_cost, Path::startup_cost, JoinCostWorkspace::startup_cost, Path::total_cost, and JoinCostWorkspace::total_cost.

Referenced by try_nestloop_path(), and try_partial_nestloop_path().

◆ set_baserel_size_estimates()

void set_baserel_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5213 of file costsize.c.

 {
     double      nrows;
  
     /* Should only be applied to base relations */
     Assert(rel->relid > 0);
  
     nrows = rel->tuples *
         clauselist_selectivity(root,
                                rel->baserestrictinfo,
                                0,
                                JOIN_INNER,
                                NULL);
  
     rel->rows = clamp_row_est(nrows);
  
     cost_qual_eval(&rel->baserestrictcost, rel->baserestrictinfo, root);
  
     set_rel_width(root, rel);
 }

References Assert, RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), JOIN_INNER, RelOptInfo::relid, root, RelOptInfo::rows, set_rel_width(), and RelOptInfo::tuples.

Referenced by postgresGetForeignRelSize(), set_cte_size_estimates(), set_function_size_estimates(), set_namedtuplestore_size_estimates(), set_plain_rel_size(), set_result_size_estimates(), set_subquery_size_estimates(), set_tablefunc_size_estimates(), set_tablesample_rel_size(), and set_values_size_estimates().

◆ set_cte_size_estimates()

void set_cte_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		double	cte_rows
	)

Definition at line 5938 of file costsize.c.

 {
     RangeTblEntry *rte;
  
     /* Should only be applied to base relations that are CTE references */
     Assert(rel->relid > 0);
     rte = planner_rt_fetch(rel->relid, root);
     Assert(rte->rtekind == RTE_CTE);
  
     if (rte->self_reference)
     {
         /*
          * In a self-reference, we assume the average worktable size is a
          * multiple of the nonrecursive term's size.  The best multiplier will
          * vary depending on query "fan-out", so make its value adjustable.
          */
         rel->tuples = clamp_row_est(recursive_worktable_factor * cte_rows);
     }
     else
     {
         /* Otherwise just believe the CTE's rowcount estimate */
         rel->tuples = cte_rows;
     }
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, clamp_row_est(), planner_rt_fetch, recursive_worktable_factor, RelOptInfo::relid, root, RTE_CTE, RangeTblEntry::rtekind, set_baserel_size_estimates(), and RelOptInfo::tuples.

Referenced by set_cte_pathlist(), and set_worktable_pathlist().

◆ set_foreign_size_estimates()

void set_foreign_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 6038 of file costsize.c.

 {
     /* Should only be applied to base relations */
     Assert(rel->relid > 0);
  
     rel->rows = 1000;           /* entirely bogus default estimate */
  
     cost_qual_eval(&rel->baserestrictcost, rel->baserestrictinfo, root);
  
     set_rel_width(root, rel);
 }

References Assert, RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, cost_qual_eval(), RelOptInfo::relid, root, RelOptInfo::rows, and set_rel_width().

Referenced by set_foreign_size().

◆ set_function_size_estimates()

void set_function_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5846 of file costsize.c.

 {
     RangeTblEntry *rte;
     ListCell   *lc;
  
     /* Should only be applied to base relations that are functions */
     Assert(rel->relid > 0);
     rte = planner_rt_fetch(rel->relid, root);
     Assert(rte->rtekind == RTE_FUNCTION);
  
     /*
      * Estimate number of rows the functions will return. The rowcount of the
      * node is that of the largest function result.
      */
     rel->tuples = 0;
     foreach(lc, rte->functions)
     {
         RangeTblFunction *rtfunc = (RangeTblFunction *) lfirst(lc);
         double      ntup = expression_returns_set_rows(root, rtfunc->funcexpr);
  
         if (ntup > rel->tuples)
             rel->tuples = ntup;
     }
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, expression_returns_set_rows(), RangeTblFunction::funcexpr, RangeTblEntry::functions, lfirst, planner_rt_fetch, RelOptInfo::relid, root, RTE_FUNCTION, RangeTblEntry::rtekind, set_baserel_size_estimates(), and RelOptInfo::tuples.

Referenced by set_rel_size().

◆ set_joinrel_size_estimates()

void set_joinrel_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		SpecialJoinInfo *	sjinfo,
		List *	restrictlist
	)

Definition at line 5292 of file costsize.c.

 {
     rel->rows = calc_joinrel_size_estimate(root,
                                            rel,
                                            outer_rel,
                                            inner_rel,
                                            outer_rel->rows,
                                            inner_rel->rows,
                                            sjinfo,
                                            restrictlist);
 }

References calc_joinrel_size_estimate(), root, and RelOptInfo::rows.

Referenced by build_child_join_rel(), and build_join_rel().

◆ set_namedtuplestore_size_estimates()

void set_namedtuplestore_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5976 of file costsize.c.

 {
     RangeTblEntry *rte;
  
     /* Should only be applied to base relations that are tuplestore references */
     Assert(rel->relid > 0);
     rte = planner_rt_fetch(rel->relid, root);
     Assert(rte->rtekind == RTE_NAMEDTUPLESTORE);
  
     /*
      * Use the estimate provided by the code which is generating the named
      * tuplestore.  In some cases, the actual number might be available; in
      * others the same plan will be re-used, so a "typical" value might be
      * estimated and used.
      */
     rel->tuples = rte->enrtuples;
     if (rel->tuples < 0)
         rel->tuples = 1000;
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, planner_rt_fetch, RelOptInfo::relid, root, RTE_NAMEDTUPLESTORE, RangeTblEntry::rtekind, set_baserel_size_estimates(), and RelOptInfo::tuples.

Referenced by set_namedtuplestore_pathlist().

◆ set_pathtarget_cost_width()

PathTarget* set_pathtarget_cost_width	(	PlannerInfo *	root,
		PathTarget *	target
	)

Definition at line 6230 of file costsize.c.

 {
     int64       tuple_width = 0;
     ListCell   *lc;
  
     /* Vars are assumed to have cost zero, but other exprs do not */
     target->cost.startup = 0;
     target->cost.per_tuple = 0;
  
     foreach(lc, target->exprs)
     {
         Node       *node = (Node *) lfirst(lc);
  
         tuple_width += get_expr_width(root, node);
  
         /* For non-Vars, account for evaluation cost */
         if (!IsA(node, Var))
         {
             QualCost    cost;
  
             cost_qual_eval_node(&cost, node, root);
             target->cost.startup += cost.startup;
             target->cost.per_tuple += cost.per_tuple;
         }
     }
  
     target->width = clamp_width_est(tuple_width);
  
     return target;
 }

References clamp_width_est(), PathTarget::cost, cost_qual_eval_node(), PathTarget::exprs, get_expr_width(), IsA, lfirst, QualCost::per_tuple, root, QualCost::startup, and PathTarget::width.

Referenced by make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), make_window_input_target(), and split_pathtarget_at_srfs().

◆ set_result_size_estimates()

void set_result_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 6009 of file costsize.c.

 {
     /* Should only be applied to RTE_RESULT base relations */
     Assert(rel->relid > 0);
     Assert(planner_rt_fetch(rel->relid, root)->rtekind == RTE_RESULT);
  
     /* RTE_RESULT always generates a single row, natively */
     rel->tuples = 1;
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, planner_rt_fetch, RelOptInfo::relid, root, RTE_RESULT, set_baserel_size_estimates(), and RelOptInfo::tuples.

Referenced by set_result_pathlist().

◆ set_subquery_size_estimates()

void set_subquery_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5766 of file costsize.c.

 {
     PlannerInfo *subroot = rel->subroot;
     RelOptInfo *sub_final_rel;
     ListCell   *lc;
  
     /* Should only be applied to base relations that are subqueries */
     Assert(rel->relid > 0);
     Assert(planner_rt_fetch(rel->relid, root)->rtekind == RTE_SUBQUERY);
  
     /*
      * Copy raw number of output rows from subquery.  All of its paths should
      * have the same output rowcount, so just look at cheapest-total.
      */
     sub_final_rel = fetch_upper_rel(subroot, UPPERREL_FINAL, NULL);
     rel->tuples = sub_final_rel->cheapest_total_path->rows;
  
     /*
      * Compute per-output-column width estimates by examining the subquery's
      * targetlist.  For any output that is a plain Var, get the width estimate
      * that was made while planning the subquery.  Otherwise, we leave it to
      * set_rel_width to fill in a datatype-based default estimate.
      */
     foreach(lc, subroot->parse->targetList)
     {
         TargetEntry *te = lfirst_node(TargetEntry, lc);
         Node       *texpr = (Node *) te->expr;
         int32       item_width = 0;
  
         /* junk columns aren't visible to upper query */
         if (te->resjunk)
             continue;
  
         /*
          * The subquery could be an expansion of a view that's had columns
          * added to it since the current query was parsed, so that there are
          * non-junk tlist columns in it that don't correspond to any column
          * visible at our query level.  Ignore such columns.
          */
         if (te->resno < rel->min_attr || te->resno > rel->max_attr)
             continue;
  
         /*
          * XXX This currently doesn't work for subqueries containing set
          * operations, because the Vars in their tlists are bogus references
          * to the first leaf subquery, which wouldn't give the right answer
          * even if we could still get to its PlannerInfo.
          *
          * Also, the subquery could be an appendrel for which all branches are
          * known empty due to constraint exclusion, in which case
          * set_append_rel_pathlist will have left the attr_widths set to zero.
          *
          * In either case, we just leave the width estimate zero until
          * set_rel_width fixes it.
          */
         if (IsA(texpr, Var) &&
             subroot->parse->setOperations == NULL)
         {
             Var        *var = (Var *) texpr;
             RelOptInfo *subrel = find_base_rel(subroot, var->varno);
  
             item_width = subrel->attr_widths[var->varattno - subrel->min_attr];
         }
         rel->attr_widths[te->resno - rel->min_attr] = item_width;
     }
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, RelOptInfo::cheapest_total_path, TargetEntry::expr, fetch_upper_rel(), find_base_rel(), if(), IsA, lfirst_node, RelOptInfo::max_attr, RelOptInfo::min_attr, PlannerInfo::parse, planner_rt_fetch, RelOptInfo::relid, TargetEntry::resno, root, Path::rows, RTE_SUBQUERY, set_baserel_size_estimates(), Query::setOperations, RelOptInfo::subroot, Query::targetList, RelOptInfo::tuples, UPPERREL_FINAL, Var::varattno, and Var::varno.

Referenced by build_setop_child_paths(), and set_subquery_pathlist().

◆ set_tablefunc_size_estimates()

void set_tablefunc_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5884 of file costsize.c.

 {
     /* Should only be applied to base relations that are functions */
     Assert(rel->relid > 0);
     Assert(planner_rt_fetch(rel->relid, root)->rtekind == RTE_TABLEFUNC);
  
     rel->tuples = 100;
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, planner_rt_fetch, RelOptInfo::relid, root, RTE_TABLEFUNC, set_baserel_size_estimates(), and RelOptInfo::tuples.

Referenced by set_rel_size().

◆ set_values_size_estimates()

void set_values_size_estimates	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 5906 of file costsize.c.

 {
     RangeTblEntry *rte;
  
     /* Should only be applied to base relations that are values lists */
     Assert(rel->relid > 0);
     rte = planner_rt_fetch(rel->relid, root);
     Assert(rte->rtekind == RTE_VALUES);
  
     /*
      * Estimate number of rows the values list will return. We know this
      * precisely based on the list length (well, barring set-returning
      * functions in list items, but that's a refinement not catered for
      * anywhere else either).
      */
     rel->tuples = list_length(rte->values_lists);
  
     /* Now estimate number of output rows, etc */
     set_baserel_size_estimates(root, rel);
 }

References Assert, list_length(), planner_rt_fetch, RelOptInfo::relid, root, RTE_VALUES, RangeTblEntry::rtekind, set_baserel_size_estimates(), RelOptInfo::tuples, and RangeTblEntry::values_lists.

Referenced by set_rel_size().

Variable Documentation

◆ constraint_exclusion

PGDLLIMPORT int constraint_exclusion

extern

Definition at line 56 of file plancat.c.

Referenced by relation_excluded_by_constraints().

◆ disable_cost

PGDLLIMPORT Cost disable_cost

extern

Definition at line 130 of file costsize.c.

Referenced by cost_agg(), cost_bitmap_heap_scan(), cost_gather_merge(), cost_index(), cost_seqscan(), cost_sort(), final_cost_hashjoin(), final_cost_mergejoin(), and final_cost_nestloop().

◆ enable_async_append

PGDLLIMPORT bool enable_async_append

extern

Definition at line 154 of file costsize.c.

Referenced by create_append_plan().

◆ enable_bitmapscan

PGDLLIMPORT bool enable_bitmapscan

extern

Definition at line 137 of file costsize.c.

Referenced by cost_bitmap_heap_scan().

◆ enable_gathermerge

PGDLLIMPORT bool enable_gathermerge

extern

Definition at line 147 of file costsize.c.

Referenced by cost_gather_merge().

◆ enable_hashagg

PGDLLIMPORT bool enable_hashagg

extern

Definition at line 141 of file costsize.c.

Referenced by choose_hashed_setop(), compute_semijoin_info(), cost_agg(), create_final_distinct_paths(), and create_partial_distinct_paths().

◆ enable_hashjoin

PGDLLIMPORT bool enable_hashjoin

extern

Definition at line 146 of file costsize.c.

Referenced by add_paths_to_joinrel(), and final_cost_hashjoin().

◆ enable_incremental_sort

PGDLLIMPORT bool enable_incremental_sort

extern

Definition at line 140 of file costsize.c.

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

◆ enable_indexonlyscan

PGDLLIMPORT bool enable_indexonlyscan

extern

Definition at line 136 of file costsize.c.

Referenced by check_index_only().

◆ enable_indexscan

PGDLLIMPORT bool enable_indexscan

extern

Definition at line 135 of file costsize.c.

Referenced by cost_index(), and plan_cluster_use_sort().

◆ enable_material

PGDLLIMPORT bool enable_material

extern

Definition at line 143 of file costsize.c.

Referenced by build_subplan(), consider_parallel_nestloop(), final_cost_mergejoin(), and match_unsorted_outer().

◆ enable_memoize

PGDLLIMPORT bool enable_memoize

extern

Definition at line 144 of file costsize.c.

Referenced by get_memoize_path().

◆ enable_mergejoin

PGDLLIMPORT bool enable_mergejoin

extern

Definition at line 145 of file costsize.c.

Referenced by add_paths_to_joinrel(), and final_cost_mergejoin().

◆ enable_nestloop

PGDLLIMPORT bool enable_nestloop

extern

Definition at line 142 of file costsize.c.

Referenced by final_cost_nestloop().

◆ enable_parallel_append

PGDLLIMPORT bool enable_parallel_append

extern

Definition at line 150 of file costsize.c.

Referenced by add_paths_to_append_rel(), and generate_union_paths().

◆ enable_parallel_hash

PGDLLIMPORT bool enable_parallel_hash

extern

Definition at line 151 of file costsize.c.

Referenced by hash_inner_and_outer().

◆ enable_partition_pruning

PGDLLIMPORT bool enable_partition_pruning

extern

Definition at line 152 of file costsize.c.

Referenced by create_append_plan(), create_merge_append_plan(), and prune_append_rel_partitions().

◆ enable_partitionwise_aggregate

PGDLLIMPORT bool enable_partitionwise_aggregate

extern

Definition at line 149 of file costsize.c.

Referenced by create_grouping_paths().

◆ enable_partitionwise_join

PGDLLIMPORT bool enable_partitionwise_join

extern

Definition at line 148 of file costsize.c.

Referenced by build_joinrel_partition_info(), and set_append_rel_size().

◆ enable_presorted_aggregate

PGDLLIMPORT bool enable_presorted_aggregate

extern

Definition at line 153 of file costsize.c.

Referenced by adjust_group_pathkeys_for_groupagg().

◆ enable_seqscan

PGDLLIMPORT bool enable_seqscan

extern

Definition at line 134 of file costsize.c.

Referenced by cost_seqscan().

◆ enable_sort

PGDLLIMPORT bool enable_sort

extern

Definition at line 139 of file costsize.c.

Referenced by cost_sort().

◆ enable_tidscan

PGDLLIMPORT bool enable_tidscan

extern

Definition at line 138 of file costsize.c.

Referenced by create_tidscan_paths().

◆ max_parallel_workers_per_gather

PGDLLIMPORT int max_parallel_workers_per_gather

extern

Definition at line 132 of file costsize.c.

Referenced by add_paths_to_append_rel(), cost_index(), create_partial_bitmap_paths(), create_plain_partial_paths(), generate_union_paths(), and standard_planner().

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DEFAULT_CPU_INDEX_TUPLE_COST

◆ DEFAULT_CPU_OPERATOR_COST

◆ DEFAULT_CPU_TUPLE_COST

◆ DEFAULT_EFFECTIVE_CACHE_SIZE

◆ DEFAULT_PARALLEL_SETUP_COST

◆ DEFAULT_PARALLEL_TUPLE_COST

◆ DEFAULT_RANDOM_PAGE_COST

◆ DEFAULT_RECURSIVE_WORKTABLE_FACTOR

◆ DEFAULT_SEQ_PAGE_COST

Enumeration Type Documentation

◆ ConstraintExclusionType

Function Documentation

◆ compute_bitmap_pages()

◆ compute_gather_rows()

◆ compute_semi_anti_join_factors()

◆ cost_agg()

◆ cost_append()

◆ cost_bitmap_and_node()

◆ cost_bitmap_heap_scan()

◆ cost_bitmap_or_node()

◆ cost_bitmap_tree_node()

◆ cost_ctescan()

◆ cost_functionscan()

◆ cost_gather()

◆ cost_gather_merge()

◆ cost_group()

◆ cost_incremental_sort()

◆ cost_index()

◆ cost_material()

◆ cost_merge_append()

◆ cost_namedtuplestorescan()

◆ cost_qual_eval()

◆ cost_qual_eval_node()

◆ cost_recursive_union()

◆ cost_resultscan()

◆ cost_samplescan()

◆ cost_seqscan()

◆ cost_sort()

◆ cost_subplan()

◆ cost_subqueryscan()

◆ cost_tablefuncscan()

◆ cost_tidrangescan()

◆ cost_tidscan()

◆ cost_valuesscan()

◆ cost_windowagg()

◆ final_cost_hashjoin()

◆ final_cost_mergejoin()

◆ final_cost_nestloop()

◆ get_parameterized_baserel_size()

◆ get_parameterized_joinrel_size()

◆ index_pages_fetched()

◆ initial_cost_hashjoin()

◆ initial_cost_mergejoin()

◆ initial_cost_nestloop()

◆ set_baserel_size_estimates()

◆ set_cte_size_estimates()

◆ set_foreign_size_estimates()

◆ set_function_size_estimates()

◆ set_joinrel_size_estimates()

◆ set_namedtuplestore_size_estimates()

◆ set_pathtarget_cost_width()

◆ set_result_size_estimates()

◆ set_subquery_size_estimates()

◆ set_tablefunc_size_estimates()

◆ set_values_size_estimates()

Variable Documentation

◆ constraint_exclusion

◆ disable_cost

◆ enable_async_append

◆ enable_bitmapscan

◆ enable_gathermerge

◆ enable_hashagg

◆ enable_hashjoin

◆ enable_incremental_sort

◆ enable_indexonlyscan