Loading...
Searching...
No Matches
cost.h File Reference
Include dependency graph for cost.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of 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 } |
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()
|
extern |
Definition at line 6661 of file costsize.c.
6664{
6665 Cost indexTotalCost;
6666 Selectivity indexSelectivity;
6669 double tuples_fetched;
6671 double maxentries;
6672
6673 /*
6674 * Fetch total cost of obtaining the bitmap, as well as its total
6675 * selectivity.
6676 */
6677 cost_bitmap_tree_node(bitmapqual, &indexTotalCost, &indexSelectivity);
6678
6679 /*
6680 * Estimate number of main-table pages fetched.
6681 */
6683
6685
6686 /*
6687 * For a single scan, the number of heap pages that need to be fetched is
6688 * the same as the Mackert and Lohman formula for the case T <= b (ie, no
6689 * re-reads needed).
6690 */
6692
6693 /*
6694 * Calculate the number of pages fetched from the heap. Then based on
6695 * current work_mem estimate get the estimated maxentries in the bitmap.
6696 * (Note that we always do this calculation based on the number of pages
6697 * that would be fetched in a single iteration, even if loop_count > 1.
6698 * That's correct, because only that number of entries will be stored in
6699 * the bitmap at one time.)
6700 */
6703
6705 {
6706 /*
6707 * For repeated bitmap scans, scale up the number of tuples fetched in
6708 * the Mackert and Lohman formula by the number of scans, so that we
6709 * estimate the number of pages fetched by all the scans. Then
6710 * pro-rate for one scan.
6711 */
6713 baserel->pages,
6714 get_indexpath_pages(bitmapqual),
6715 root);
6717 }
6718
6721 else
6723
6725 {
6726 double exact_pages;
6727 double lossy_pages;
6728
6729 /*
6730 * Crude approximation of the number of lossy pages. Because of the
6731 * way tbm_lossify() is coded, the number of lossy pages increases
6732 * very sharply as soon as we run short of memory; this formula has
6733 * that property and seems to perform adequately in testing, but it's
6734 * possible we could do better somehow.
6735 */
6737 exact_pages = heap_pages - lossy_pages;
6738
6739 /*
6740 * If there are lossy pages then recompute the number of tuples
6741 * processed by the bitmap heap node. We assume here that the chance
6742 * of a given tuple coming from an exact page is the same as the
6743 * chance that a given page is exact. This might not be true, but
6744 * it's not clear how we can do any better.
6745 */
6746 if (lossy_pages > 0)
6747 tuples_fetched =
6748 clamp_row_est(indexSelectivity *
6751 }
6752
6754 *cost_p = indexTotalCost;
6756 *tuples_p = tuples_fetched;
6757
6759}
double index_pages_fetched(double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root)
Definition costsize.c:896
void cost_bitmap_tree_node(Path *path, Cost *cost, Selectivity *selec)
Definition costsize.c:1114
References clamp_row_est(), cost_bitmap_tree_node(), fb(), get_indexpath_pages(), index_pages_fetched(), Max, Min, root, T, tbm_calculate_entries(), and work_mem.
Referenced by cost_bitmap_heap_scan(), and create_partial_bitmap_paths().
◆ compute_gather_rows()
Definition at line 6772 of file costsize.c.
6773{
6775
6777}
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()
|
extern |
Definition at line 5261 of file costsize.c.
5269{
5275 ListCell *l;
5276
5277 /*
5278 * In an ANTI join, we must ignore clauses that are "pushed down", since
5279 * those won't affect the match logic. In a SEMI join, we do not
5280 * distinguish joinquals from "pushed down" quals, so just use the whole
5281 * restrictinfo list. For other outer join types, we should consider only
5282 * non-pushed-down quals, so that this devolves to an IS_OUTER_JOIN check.
5283 */
5285 {
5287 foreach(l, restrictlist)
5288 {
5290
5293 }
5294 }
5295 else
5296 joinquals = restrictlist;
5297
5298 /*
5299 * Get the JOIN_SEMI or JOIN_ANTI selectivity of the join clauses.
5300 */
5302 joinquals,
5303 0,
5305 sjinfo);
5306
5307 /*
5308 * Also get the normal inner-join selectivity of the join clauses.
5309 */
5311
5313 joinquals,
5314 0,
5315 JOIN_INNER,
5316 &norm_sjinfo);
5317
5318 /* Avoid leaking a lot of ListCells */
5321
5322 /*
5323 * jselec can be interpreted as the fraction of outer-rel rows that have
5324 * any matches (this is true for both SEMI and ANTI cases). And nselec is
5325 * the fraction of the Cartesian product that matches. So, the average
5326 * number of matches for each outer-rel row that has at least one match is
5327 * nselec * inner_rows / jselec.
5328 *
5329 * Note: it is correct to use the inner rel's "rows" count here, even
5330 * though we might later be considering a parameterized inner path with
5331 * fewer rows. This is because we have included all the join clauses in
5332 * the selectivity estimate.
5333 */
5335 {
5337 /* Clamp to sane range */
5339 }
5340 else
5341 avgmatch = 1.0;
5342
5345}
Selectivity clauselist_selectivity(PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition clausesel.c:100
void init_dummy_sjinfo(SpecialJoinInfo *sjinfo, Relids left_relids, Relids right_relids)
Definition joinrels.c:664
Definition pg_list.h:54
Definition pathnodes.h:2864
Definition pathnodes.h:3191
Definition pg_list.h:46
References clauselist_selectivity(), fb(), 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()
|
extern |
Definition at line 2792 of file costsize.c.
2799{
2801 Cost startup_cost;
2802 Cost total_cost;
2804
2805 /* Use all-zero per-aggregate costs if NULL is passed */
2807 {
2810 }
2811
2812 /*
2813 * The transCost.per_tuple component of aggcosts should be charged once
2814 * per input tuple, corresponding to the costs of evaluating the aggregate
2815 * transfns and their input expressions. The finalCost.per_tuple component
2816 * is charged once per output tuple, corresponding to the costs of
2817 * evaluating the finalfns. Startup costs are of course charged but once.
2818 *
2819 * If we are grouping, we charge an additional cpu_operator_cost per
2820 * grouping column per input tuple for grouping comparisons.
2821 *
2822 * We will produce a single output tuple if not grouping, and a tuple per
2823 * group otherwise. We charge cpu_tuple_cost for each output tuple.
2824 *
2825 * Note: in this cost model, AGG_SORTED and AGG_HASHED have exactly the
2826 * same total CPU cost, but AGG_SORTED has lower startup cost. If the
2827 * input path is already sorted appropriately, AGG_SORTED should be
2828 * preferred (since it has no risk of memory overflow). This will happen
2829 * as long as the computed total costs are indeed exactly equal --- but if
2830 * there's roundoff error we might do the wrong thing. So be sure that
2831 * the computations below form the same intermediate values in the same
2832 * order.
2833 */
2835 {
2836 startup_cost = input_total_cost;
2837 startup_cost += aggcosts->transCost.startup;
2838 startup_cost += aggcosts->transCost.per_tuple * input_tuples;
2839 startup_cost += aggcosts->finalCost.startup;
2840 startup_cost += aggcosts->finalCost.per_tuple;
2841 /* we aren't grouping */
2842 total_cost = startup_cost + cpu_tuple_cost;
2843 output_tuples = 1;
2844 }
2846 {
2847 /* Here we are able to deliver output on-the-fly */
2848 startup_cost = input_startup_cost;
2849 total_cost = input_total_cost;
2851 ++disabled_nodes;
2852 /* calcs phrased this way to match HASHED case, see note above */
2853 total_cost += aggcosts->transCost.startup;
2854 total_cost += aggcosts->transCost.per_tuple * input_tuples;
2856 total_cost += aggcosts->finalCost.startup;
2857 total_cost += aggcosts->finalCost.per_tuple * numGroups;
2858 total_cost += cpu_tuple_cost * numGroups;
2859 output_tuples = numGroups;
2860 }
2861 else
2862 {
2863 /* must be AGG_HASHED */
2864 startup_cost = input_total_cost;
2866 ++disabled_nodes;
2867 startup_cost += aggcosts->transCost.startup;
2868 startup_cost += aggcosts->transCost.per_tuple * input_tuples;
2869 /* cost of computing hash value */
2871 startup_cost += aggcosts->finalCost.startup;
2872
2873 total_cost = startup_cost;
2874 total_cost += aggcosts->finalCost.per_tuple * numGroups;
2875 /* cost of retrieving from hash table */
2876 total_cost += cpu_tuple_cost * numGroups;
2877 output_tuples = numGroups;
2878 }
2879
2880 /*
2881 * Add the disk costs of hash aggregation that spills to disk.
2882 *
2883 * Groups that go into the hash table stay in memory until finalized, so
2884 * spilling and reprocessing tuples doesn't incur additional invocations
2885 * of transCost or finalCost. Furthermore, the computed hash value is
2886 * stored with the spilled tuples, so we don't incur extra invocations of
2887 * the hash function.
2888 *
2889 * Hash Agg begins returning tuples after the first batch is complete.
2890 * Accrue writes (spilled tuples) to startup_cost and to total_cost;
2891 * accrue reads only to total_cost.
2892 */
2894 {
2895 double pages;
2899 double hashentrysize;
2901 Size mem_limit;
2903 int num_partitions;
2904 int depth;
2905
2906 /*
2907 * Estimate number of batches based on the computed limits. If less
2908 * than or equal to one, all groups are expected to fit in memory;
2909 * otherwise we expect to spill.
2910 */
2912 input_width,
2913 aggcosts->transitionSpace);
2914 hash_agg_set_limits(hashentrysize, numGroups, 0, &mem_limit,
2915 &ngroups_limit, &num_partitions);
2916
2918 numGroups / ngroups_limit);
2919
2921 num_partitions = Max(num_partitions, 2);
2922
2923 /*
2924 * The number of partitions can change at different levels of
2925 * recursion; but for the purposes of this calculation assume it stays
2926 * constant.
2927 */
2929
2930 /*
2931 * Estimate number of pages read and written. For each level of
2932 * recursion, a tuple must be written and then later read.
2933 */
2936
2937 /*
2938 * HashAgg has somewhat worse IO behavior than Sort on typical
2939 * hardware/OS combinations. Account for this with a generic penalty.
2940 */
2941 pages_read *= 2.0;
2942 pages_written *= 2.0;
2943
2947
2948 /* account for CPU cost of spilling a tuple and reading it back */
2950 startup_cost += spill_cost;
2951 total_cost += spill_cost;
2952 }
2953
2954 /*
2955 * If there are quals (HAVING quals), account for their cost and
2956 * selectivity.
2957 */
2958 if (quals)
2959 {
2961
2963 startup_cost += qual_cost.startup;
2965
2968 quals,
2969 0,
2970 JOIN_INNER,
2971 NULL));
2972 }
2973
2975 path->disabled_nodes = disabled_nodes;
2976 path->startup_cost = startup_cost;
2977 path->total_cost = total_cost;
2978}
static double relation_byte_size(double tuples, int width)
Definition costsize.c:6600
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
Definition costsize.c:4903
Size hash_agg_entry_size(int numTrans, Size tupleWidth, Size transitionSpace)
Definition nodeAgg.c:1698
void hash_agg_set_limits(double hashentrysize, double input_groups, int used_bits, Size *mem_limit, uint64 *ngroups_limit, int *num_partitions)
Definition nodeAgg.c:1806
Definition pathnodes.h:132
Definition pathnodes.h:119
References AGG_HASHED, AGG_MIXED, AGG_PLAIN, AGG_SORTED, Assert, clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), cpu_operator_cost, cpu_tuple_cost, Path::disabled_nodes, enable_hashagg, fb(), hash_agg_entry_size(), hash_agg_set_limits(), JOIN_INNER, list_length(), Max, random_page_cost, relation_byte_size(), root, Path::rows, seq_page_cost, Path::startup_cost, and Path::total_cost.
Referenced by create_agg_path(), and create_groupingsets_path().
◆ cost_append()
|
extern |
Definition at line 2310 of file costsize.c.
2311{
2313 ListCell *l;
2315
2318
2319 apath->path.disabled_nodes =
2321 apath->path.startup_cost = 0;
2322 apath->path.total_cost = 0;
2323 apath->path.rows = 0;
2324
2326 return;
2327
2329 {
2331
2333 {
2335
2336 /*
2337 * For an unordered, non-parallel-aware Append we take the startup
2338 * cost as the startup cost of the first subpath.
2339 */
2341
2342 /*
2343 * Compute rows, number of disabled nodes, and total cost as sums
2344 * of underlying subplan values.
2345 */
2347 {
2349
2353 }
2354 }
2355 else
2356 {
2357 /*
2358 * For an ordered, non-parallel-aware Append we take the startup
2359 * cost as the sum of the subpath startup costs. This ensures
2360 * that we don't underestimate the startup cost when a query's
2361 * LIMIT is such that several of the children have to be run to
2362 * satisfy it. This might be overkill --- another plausible hack
2363 * would be to take the Append's startup cost as the maximum of
2364 * the child startup costs. But we don't want to risk believing
2365 * that an ORDER BY LIMIT query can be satisfied at small cost
2366 * when the first child has small startup cost but later ones
2367 * don't. (If we had the ability to deal with nonlinear cost
2368 * interpolation for partial retrievals, we would not need to be
2369 * so conservative about this.)
2370 *
2371 * This case is also different from the above in that we have to
2372 * account for possibly injecting sorts into subpaths that aren't
2373 * natively ordered.
2374 */
2376 {
2378 int presorted_keys;
2380 * cost_sort/cost_incremental_sort */
2381
2383 &presorted_keys))
2384 {
2385 /*
2386 * We'll need to insert a Sort node, so include costs for
2387 * that. We choose to use incremental sort if it is
2388 * enabled and there are presorted keys; otherwise we use
2389 * full sort.
2390 *
2391 * We can use the parent's LIMIT if any, since we
2392 * certainly won't pull more than that many tuples from
2393 * any child.
2394 */
2396 {
2398 root,
2399 pathkeys,
2400 presorted_keys,
2401 subpath->disabled_nodes,
2402 subpath->startup_cost,
2403 subpath->total_cost,
2404 subpath->rows,
2405 subpath->pathtarget->width,
2406 0.0,
2407 work_mem,
2408 apath->limit_tuples);
2409 }
2410 else
2411 {
2413 root,
2414 pathkeys,
2415 subpath->disabled_nodes,
2416 subpath->total_cost,
2417 subpath->rows,
2418 subpath->pathtarget->width,
2419 0.0,
2420 work_mem,
2421 apath->limit_tuples);
2422 }
2423
2425 }
2426
2431 }
2432 }
2433 }
2434 else /* parallel-aware */
2435 {
2438
2439 /* Parallel-aware Append never produces ordered output. */
2441
2442 /* Calculate startup cost. */
2444 {
2446
2447 /*
2448 * Append will start returning tuples when the child node having
2449 * lowest startup cost is done setting up. We consider only the
2450 * first few subplans that immediately get a worker assigned.
2451 */
2456 subpath->startup_cost);
2457
2458 /*
2459 * Apply parallel divisor to subpaths. Scale the number of rows
2460 * for each partial subpath based on the ratio of the parallel
2461 * divisor originally used for the subpath to the one we adopted.
2462 * Also add the cost of partial paths to the total cost, but
2463 * ignore non-partial paths for now.
2464 */
2467 else
2468 {
2470
2473 parallel_divisor);
2475 }
2476
2479
2480 i++;
2481 }
2482
2483 /* Add cost for non-partial subpaths. */
2484 apath->path.total_cost +=
2486 apath->first_partial_path,
2487 apath->path.parallel_workers);
2488 }
2489
2490 /*
2491 * Although Append does not do any selection or projection, it's not free;
2492 * add a small per-tuple overhead.
2493 */
2494 apath->path.total_cost +=
2496}
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, int input_disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
Definition costsize.c:2200
void cost_incremental_sort(Path *path, PlannerInfo *root, List *pathkeys, int presorted_keys, int input_disabled_nodes, Cost input_startup_cost, Cost input_total_cost, double input_tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
Definition costsize.c:2052
static Cost append_nonpartial_cost(List *subpaths, int numpaths, int parallel_workers)
Definition costsize.c:2234
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition pathkeys.c:558
Definition pathnodes.h:1945
Definition pathnodes.h:992
References APPEND_CPU_COST_MULTIPLIER, append_nonpartial_cost(), Assert, clamp_row_est(), cost_incremental_sort(), cost_sort(), cpu_tuple_cost, enable_incremental_sort, fb(), get_parallel_divisor(), i, lfirst, linitial, Min, NIL, pathkeys_count_contained_in(), PGS_APPEND, PGS_CONSIDER_NONPARTIAL, RelOptInfo::pgs_mask, root, Path::rows, Path::startup_cost, subpath(), and work_mem.
Referenced by create_append_path().
◆ cost_bitmap_and_node()
|
extern |
Definition at line 1157 of file costsize.c.
1158{
1161 ListCell *l;
1162
1163 /*
1164 * We estimate AND selectivity on the assumption that the inputs are
1165 * independent. This is probably often wrong, but we don't have the info
1166 * to do better.
1167 *
1168 * The runtime cost of the BitmapAnd itself is estimated at 100x
1169 * cpu_operator_cost for each tbm_intersect needed. Probably too small,
1170 * definitely too simplistic?
1171 */
1172 totalCost = 0.0;
1173 selec = 1.0;
1175 {
1179
1181
1183
1187 }
1193}
References BitmapAndPath::bitmapquals, BitmapAndPath::bitmapselectivity, cost_bitmap_tree_node(), cpu_operator_cost, Path::disabled_nodes, fb(), 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()
|
extern |
Definition at line 1011 of file costsize.c.
1014{
1015 Cost startup_cost = 0;
1016 Cost run_cost = 0;
1017 Cost indexTotalCost;
1022 double tuples_fetched;
1025 spc_random_page_cost;
1028
1029 /* Should only be applied to base relations */
1033
1034 /* Mark the path with the correct row estimate */
1037 else
1039
1041 loop_count, &indexTotalCost,
1042 &tuples_fetched);
1043
1044 startup_cost += indexTotalCost;
1046
1047 /* Fetch estimated page costs for tablespace containing table. */
1049 &spc_random_page_cost,
1050 &spc_seq_page_cost);
1051
1052 /*
1053 * For small numbers of pages we should charge spc_random_page_cost
1054 * apiece, while if nearly all the table's pages are being read, it's more
1055 * appropriate to charge spc_seq_page_cost apiece. The effect is
1056 * nonlinear, too. For lack of a better idea, interpolate like this to
1057 * determine the cost per page.
1058 */
1060 cost_per_page = spc_random_page_cost -
1061 (spc_random_page_cost - spc_seq_page_cost)
1063 else
1064 cost_per_page = spc_random_page_cost;
1065
1067
1068 /*
1069 * Estimate CPU costs per tuple.
1070 *
1071 * Often the indexquals don't need to be rechecked at each tuple ... but
1072 * not always, especially not if there are enough tuples involved that the
1073 * bitmaps become lossy. For the moment, just assume they will be
1074 * rechecked always. This means we charge the full freight for all the
1075 * scan clauses.
1076 */
1078
1079 startup_cost += qpqual_cost.startup;
1082
1083 /* Adjust costing for parallelism, if used. */
1085 {
1087
1088 /* The CPU cost is divided among all the workers. */
1090
1092 }
1093 else
1095
1096
1097 run_cost += cpu_run_cost;
1098
1099 /* tlist eval costs are paid per output row, not per tuple scanned */
1100 startup_cost += path->pathtarget->cost.startup;
1101 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1102
1103 path->disabled_nodes =
1105 path->startup_cost = startup_cost;
1106 path->total_cost = startup_cost + run_cost;
1107}
static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info, QualCost *qpqual_cost)
Definition costsize.c:5219
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition costsize.c:6661
void get_tablespace_page_costs(Oid spcid, double *spc_random_page_cost, double *spc_seq_page_cost)
Definition spccache.c:182
References Assert, clamp_row_est(), compute_bitmap_pages(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_parallel_divisor(), get_restriction_qual_cost(), get_tablespace_page_costs(), IsA, Path::parallel_workers, PGS_BITMAPSCAN, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_RELATION, Path::startup_cost, T, and Path::total_cost.
Referenced by bitmap_scan_cost_est(), and create_bitmap_heap_path().
◆ cost_bitmap_or_node()
|
extern |
Definition at line 1202 of file costsize.c.
1203{
1206 ListCell *l;
1207
1208 /*
1209 * We estimate OR selectivity on the assumption that the inputs are
1210 * non-overlapping, since that's often the case in "x IN (list)" type
1211 * situations. Of course, we clamp to 1.0 at the end.
1212 *
1213 * The runtime cost of the BitmapOr itself is estimated at 100x
1214 * cpu_operator_cost for each tbm_union needed. Probably too small,
1215 * definitely too simplistic? We are aware that the tbm_unions are
1216 * optimized out when the inputs are BitmapIndexScans.
1217 */
1218 totalCost = 0.0;
1219 selec = 0.0;
1221 {
1225
1227
1229
1234 }
1239}
Definition pathnodes.h:2034
References BitmapOrPath::bitmapquals, BitmapOrPath::bitmapselectivity, cost_bitmap_tree_node(), cpu_operator_cost, fb(), 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()
|
extern |
Definition at line 1114 of file costsize.c.
1115{
1117 {
1118 *cost = ((IndexPath *) path)->indextotalcost;
1120
1121 /*
1122 * Charge a small amount per retrieved tuple to reflect the costs of
1123 * manipulating the bitmap. This is mostly to make sure that a bitmap
1124 * scan doesn't look to be the same cost as an indexscan to retrieve a
1125 * single tuple.
1126 */
1128 }
1130 {
1131 *cost = path->total_cost;
1133 }
1135 {
1136 *cost = path->total_cost;
1138 }
1139 else
1140 {
1143 }
1144}
Definition pathnodes.h:2121
Definition pathnodes.h:2134
References cpu_operator_cost, elog, ERROR, fb(), 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()
|
extern |
Definition at line 1744 of file costsize.c.
1746{
1747 Cost startup_cost = 0;
1748 Cost run_cost = 0;
1752
1753 /* Should only be applied to base relations that are CTEs */
1756
1757 /* Mark the path with the correct row estimate */
1760 else
1762
1763 /* Charge one CPU tuple cost per row for tuplestore manipulation */
1765
1766 /* Add scanning CPU costs */
1768
1769 startup_cost += qpqual_cost.startup;
1772
1773 /* tlist eval costs are paid per output row, not per tuple scanned */
1774 startup_cost += path->pathtarget->cost.startup;
1775 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1776
1779 path->disabled_nodes =
1781 path->startup_cost = startup_cost;
1782 path->total_cost = startup_cost + run_cost;
1783}
References Assert, cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_CTE, Path::startup_cost, and Path::total_cost.
Referenced by create_ctescan_path(), and create_worktablescan_path().
◆ cost_functionscan()
|
extern |
Definition at line 1562 of file costsize.c.
1564{
1565 Cost startup_cost = 0;
1566 Cost run_cost = 0;
1572
1573 /* Should only be applied to base relations that are functions */
1577
1578 /* Mark the path with the correct row estimate */
1581 else
1583
1584 /*
1585 * Estimate costs of executing the function expression(s).
1586 *
1587 * Currently, nodeFunctionscan.c always executes the functions to
1588 * completion before returning any rows, and caches the results in a
1589 * tuplestore. So the function eval cost is all startup cost, and per-row
1590 * costs are minimal.
1591 *
1592 * XXX in principle we ought to charge tuplestore spill costs if the
1593 * number of rows is large. However, given how phony our rowcount
1594 * estimates for functions tend to be, there's not a lot of point in that
1595 * refinement right now.
1596 */
1598
1600
1601 /* Add scanning CPU costs */
1603
1604 startup_cost += qpqual_cost.startup;
1607
1608 /* tlist eval costs are paid per output row, not per tuple scanned */
1609 startup_cost += path->pathtarget->cost.startup;
1610 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1611
1614 path->disabled_nodes =
1616 path->startup_cost = startup_cost;
1617 path->total_cost = startup_cost + run_cost;
1618}
void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
Definition costsize.c:4929
Definition nodes.h:135
Definition parsenodes.h:1085
References Assert, cost_qual_eval_node(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, planner_rt_fetch, root, Path::rows, RTE_FUNCTION, Path::startup_cost, and Path::total_cost.
Referenced by create_functionscan_path().
◆ cost_gather()
|
extern |
Definition at line 429 of file costsize.c.
432{
433 Cost startup_cost = 0;
434 Cost run_cost = 0;
435
436 /* Mark the path with the correct row estimate */
437 if (rows)
441 else
443
445
447
448 /* Parallel setup and communication cost. */
449 startup_cost += parallel_setup_cost;
451
456}
References Path::disabled_nodes, fb(), parallel_setup_cost, parallel_tuple_cost, GatherPath::path, PGS_GATHER, RelOptInfo::pgs_mask, RelOptInfo::rows, Path::rows, Path::startup_cost, GatherPath::subpath, and Path::total_cost.
Referenced by create_gather_path().
◆ cost_gather_merge()
|
extern |
Definition at line 469 of file costsize.c.
474{
475 Cost startup_cost = 0;
476 Cost run_cost = 0;
478 double N;
480
481 /* Mark the path with the correct row estimate */
482 if (rows)
486 else
488
489 /*
490 * Add one to the number of workers to account for the leader. This might
491 * be overgenerous since the leader will do less work than other workers
492 * in typical cases, but we'll go with it for now.
493 */
497
498 /* Assumed cost per tuple comparison */
500
501 /* Heap creation cost */
503
504 /* Per-tuple heap maintenance cost */
506
507 /* small cost for heap management, like cost_merge_append */
509
510 /*
511 * Parallel setup and communication cost. Since Gather Merge, unlike
512 * Gather, requires us to block until a tuple is available from every
513 * worker, we bump the IPC cost up a little bit as compared with Gather.
514 * For lack of a better idea, charge an extra 5%.
515 */
516 startup_cost += parallel_setup_cost;
518
523}
References Assert, cpu_operator_cost, Path::disabled_nodes, fb(), LOG2, GatherMergePath::num_workers, parallel_setup_cost, parallel_tuple_cost, GatherMergePath::path, PGS_GATHER_MERGE, RelOptInfo::pgs_mask, RelOptInfo::rows, Path::rows, Path::startup_cost, GatherMergePath::subpath, and Path::total_cost.
Referenced by create_gather_merge_path().
◆ cost_group()
|
extern |
Definition at line 3305 of file costsize.c.
3311{
3313 Cost startup_cost;
3314 Cost total_cost;
3315
3316 output_tuples = numGroups;
3317 startup_cost = input_startup_cost;
3318 total_cost = input_total_cost;
3319
3320 /*
3321 * Charge one cpu_operator_cost per comparison per input tuple. We assume
3322 * all columns get compared at most of the tuples.
3323 */
3325
3326 /*
3327 * If there are quals (HAVING quals), account for their cost and
3328 * selectivity.
3329 */
3330 if (quals)
3331 {
3333
3335 startup_cost += qual_cost.startup;
3337
3340 quals,
3341 0,
3342 JOIN_INNER,
3343 NULL));
3344 }
3345
3348 path->startup_cost = startup_cost;
3349 path->total_cost = total_cost;
3350}
References clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), cpu_operator_cost, Path::disabled_nodes, fb(), JOIN_INNER, root, Path::rows, Path::startup_cost, and Path::total_cost.
Referenced by create_group_path().
◆ cost_incremental_sort()
|
extern |
Definition at line 2052 of file costsize.c.
2058{
2059 Cost startup_cost,
2060 run_cost,
2063 input_groups;
2065 group_run_cost,
2066 group_input_run_cost;
2068 ListCell *l;
2070
2072
2073 /*
2074 * We want to be sure the cost of a sort is never estimated as zero, even
2075 * if passed-in tuple count is zero. Besides, mustn't do log(0)...
2076 */
2077 if (input_tuples < 2.0)
2078 input_tuples = 2.0;
2079
2080 /* Default estimate of number of groups, capped to one group per row. */
2082
2083 /*
2084 * Extract presorted keys as list of expressions.
2085 *
2086 * We need to be careful about Vars containing "varno 0" which might have
2087 * been introduced by generate_append_tlist, which would confuse
2088 * estimate_num_groups (in fact it'd fail for such expressions). See
2089 * recurse_set_operations which has to deal with the same issue.
2090 *
2091 * Unlike recurse_set_operations we can't access the original target list
2092 * here, and even if we could it's not very clear how useful would that be
2093 * for a set operation combining multiple tables. So we simply detect if
2094 * there are any expressions with "varno 0" and use the default
2095 * DEFAULT_NUM_DISTINCT in that case.
2096 *
2097 * We might also use either 1.0 (a single group) or input_tuples (each row
2098 * being a separate group), pretty much the worst and best case for
2099 * incremental sort. But those are extreme cases and using something in
2100 * between seems reasonable. Furthermore, generate_append_tlist is used
2101 * for set operations, which are likely to produce mostly unique output
2102 * anyway - from that standpoint the DEFAULT_NUM_DISTINCT is defensive
2103 * while maintaining lower startup cost.
2104 */
2105 foreach(l, pathkeys)
2106 {
2110
2111 /*
2112 * Check if the expression contains Var with "varno 0" so that we
2113 * don't call estimate_num_groups in that case.
2114 */
2116 {
2118 break;
2119 }
2120
2121 /* expression not containing any Vars with "varno 0" */
2123
2125 break;
2126 }
2127
2128 /* Estimate the number of groups with equal presorted keys. */
2132
2135
2136 /*
2137 * Estimate the average cost of sorting of one group where presorted keys
2138 * are equal.
2139 */
2142 limit_tuples);
2143
2144 /*
2145 * Startup cost of incremental sort is the startup cost of its first group
2146 * plus the cost of its input.
2147 */
2149 group_input_run_cost;
2150
2151 /*
2152 * After we started producing tuples from the first group, the cost of
2153 * producing all the tuples is given by the cost to finish processing this
2154 * group, plus the total cost to process the remaining groups, plus the
2155 * remaining cost of input.
2156 */
2159
2160 /*
2161 * Incremental sort adds some overhead by itself. Firstly, it has to
2162 * detect the sort groups. This is roughly equal to one extra copy and
2163 * comparison per tuple.
2164 */
2166
2167 /*
2168 * Additionally, we charge double cpu_tuple_cost for each input group to
2169 * account for the tuplesort_reset that's performed after each group.
2170 */
2172
2173 path->rows = input_tuples;
2174
2175 /*
2176 * We should not generate these paths when enable_incremental_sort=false.
2177 * We can ignore PGS_CONSIDER_NONPARTIAL here, because if it's relevant,
2178 * it will have already affected the input path.
2179 */
2182
2183 path->startup_cost = startup_cost;
2184 path->total_cost = startup_cost + run_cost;
2185}
static void cost_tuplesort(Cost *startup_cost, Cost *run_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
Definition costsize.c:1950
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3771
Definition pathnodes.h:1695
Definition pathnodes.h:1787
References Assert, bms_is_member(), cost_tuplesort(), cpu_tuple_cost, DEFAULT_NUM_DISTINCT, Path::disabled_nodes, EquivalenceMember::em_expr, enable_incremental_sort, estimate_num_groups(), fb(), foreach_current_index, lappend(), lfirst, linitial, list_length(), Min, NIL, pull_varnos(), root, Path::rows, Path::startup_cost, and Path::total_cost.
Referenced by cost_append(), create_incremental_sort_path(), create_merge_append_path(), initial_cost_mergejoin(), and label_incrementalsort_with_costsize().
◆ cost_index()
|
extern |
Definition at line 544 of file costsize.c.
546{
550 amcostestimate_function amcostestimate;
552 Cost startup_cost = 0;
553 Cost run_cost = 0;
555 Cost indexStartupCost;
556 Cost indexTotalCost;
557 Selectivity indexSelectivity;
558 double indexCorrelation,
559 csquared;
561 spc_random_page_cost;
563 max_IO_cost;
566 double tuples_fetched;
571
572 /* Should only be applied to base relations */
577
578 /*
579 * Mark the path with the correct row estimate, and identify which quals
580 * will need to be enforced as qpquals. We need not check any quals that
581 * are implied by the index's predicate, so we can use indrestrictinfo not
582 * baserestrictinfo as the list of relevant restriction clauses for the
583 * rel.
584 */
586 {
588 /* qpquals come from the rel's restriction clauses and ppi_clauses */
590 path->indexclauses),
592 path->indexclauses));
593 }
594 else
595 {
597 /* qpquals come from just the rel's restriction clauses */
599 path->indexclauses);
600 }
601
602 /* is this scan type disabled? */
607
608 /*
609 * Call index-access-method-specific code to estimate the processing cost
610 * for scanning the index, as well as the selectivity of the index (ie,
611 * the fraction of main-table tuples we will have to retrieve) and its
612 * correlation to the main-table tuple order. We need a cast here because
613 * pathnodes.h uses a weak function type to avoid including amapi.h.
614 */
617 &indexStartupCost, &indexTotalCost,
618 &indexSelectivity, &indexCorrelation,
619 &index_pages);
620
621 /*
622 * Save amcostestimate's results for possible use in bitmap scan planning.
623 * We don't bother to save indexStartupCost or indexCorrelation, because a
624 * bitmap scan doesn't care about either.
625 */
626 path->indextotalcost = indexTotalCost;
627 path->indexselectivity = indexSelectivity;
628
629 /* all costs for touching index itself included here */
630 startup_cost += indexStartupCost;
631 run_cost += indexTotalCost - indexStartupCost;
632
633 /* estimate number of main-table tuples fetched */
635
636 /* fetch estimated page costs for tablespace containing table */
638 &spc_random_page_cost,
639 &spc_seq_page_cost);
640
641 /*----------
642 * Estimate number of main-table pages fetched, and compute I/O cost.
643 *
644 * When the index ordering is uncorrelated with the table ordering,
645 * we use an approximation proposed by Mackert and Lohman (see
646 * index_pages_fetched() for details) to compute the number of pages
647 * fetched, and then charge spc_random_page_cost per page fetched.
648 *
649 * When the index ordering is exactly correlated with the table ordering
650 * (just after a CLUSTER, for example), the number of pages fetched should
651 * be exactly selectivity * table_size. What's more, all but the first
652 * will be sequential fetches, not the random fetches that occur in the
653 * uncorrelated case. So if the number of pages is more than 1, we
654 * ought to charge
655 * spc_random_page_cost + (pages_fetched - 1) * spc_seq_page_cost
656 * For partially-correlated indexes, we ought to charge somewhere between
657 * these two estimates. We currently interpolate linearly between the
658 * estimates based on the correlation squared (XXX is that appropriate?).
659 *
660 * If it's an index-only scan, then we will not need to fetch any heap
661 * pages for which the visibility map shows all tuples are visible.
662 * Hence, reduce the estimated number of heap fetches accordingly.
663 * We use the measured fraction of the entire heap that is all-visible,
664 * which might not be particularly relevant to the subset of the heap
665 * that this query will fetch; but it's not clear how to do better.
666 *----------
667 */
669 {
670 /*
671 * For repeated indexscans, the appropriate estimate for the
672 * uncorrelated case is to scale up the number of tuples fetched in
673 * the Mackert and Lohman formula by the number of scans, so that we
674 * estimate the number of pages fetched by all the scans; then
675 * pro-rate the costs for one scan. In this case we assume all the
676 * fetches are random accesses.
677 */
679 baserel->pages,
681 root);
682
685
687
689
690 /*
691 * In the perfectly correlated case, the number of pages touched by
692 * each scan is selectivity * table_size, and we can use the Mackert
693 * and Lohman formula at the page level to estimate how much work is
694 * saved by caching across scans. We still assume all the fetches are
695 * random, though, which is an overestimate that's hard to correct for
696 * without double-counting the cache effects. (But in most cases
697 * where such a plan is actually interesting, only one page would get
698 * fetched per scan anyway, so it shouldn't matter much.)
699 */
701
703 baserel->pages,
705 root);
706
709
711 }
712 else
713 {
714 /*
715 * Normal case: apply the Mackert and Lohman formula, and then
716 * interpolate between that and the correlation-derived result.
717 */
719 baserel->pages,
721 root);
722
725
727
728 /* max_IO_cost is for the perfectly uncorrelated case (csquared=0) */
730
731 /* min_IO_cost is for the perfectly correlated case (csquared=1) */
733
736
738 {
739 min_IO_cost = spc_random_page_cost;
742 }
743 else
744 min_IO_cost = 0;
745 }
746
748 {
749 /*
750 * For index only scans compute workers based on number of index pages
751 * fetched; the number of heap pages we fetch might be so small as to
752 * effectively rule out parallelism, which we don't want to do.
753 */
755 rand_heap_pages = -1;
756
757 /*
758 * Estimate the number of parallel workers required to scan index. Use
759 * the number of heap pages computed considering heap fetches won't be
760 * sequential as for parallel scans the pages are accessed in random
761 * order.
762 */
764 rand_heap_pages,
765 index_pages,
767
768 /*
769 * Fall out if workers can't be assigned for parallel scan, because in
770 * such a case this path will be rejected. So there is no benefit in
771 * doing extra computation.
772 */
774 return;
775
777 }
778
779 /*
780 * Now interpolate based on estimated index order correlation to get total
781 * disk I/O cost for main table accesses.
782 */
783 csquared = indexCorrelation * indexCorrelation;
784
786
787 /*
788 * Estimate CPU costs per tuple.
789 *
790 * What we want here is cpu_tuple_cost plus the evaluation costs of any
791 * qual clauses that we have to evaluate as qpquals.
792 */
794
795 startup_cost += qpqual_cost.startup;
797
799
800 /* tlist eval costs are paid per output row, not per tuple scanned */
801 startup_cost += path->path.pathtarget->cost.startup;
803
804 /* Adjust costing for parallelism, if used. */
806 {
808
810
811 /* The CPU cost is divided among all the workers. */
813 }
814
815 run_cost += cpu_run_cost;
816
819}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition allpaths.c:4726
void(* amcostestimate_function)(PlannerInfo *root, IndexPath *path, double loop_count, Cost *indexStartupCost, Cost *indexTotalCost, Selectivity *indexSelectivity, double *indexCorrelation, double *indexPages)
Definition amapi.h:148
static List * extract_nonindex_conditions(List *qual_clauses, List *indexclauses)
Definition costsize.c:838
Definition pathnodes.h:1329
References Assert, clamp_row_est(), compute_parallel_worker(), cost_qual_eval(), cpu_tuple_cost, Path::disabled_nodes, extract_nonindex_conditions(), fb(), 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, Path::parallel_aware, Path::parallel_workers, IndexPath::path, Path::pathtype, PGS_CONSIDER_NONPARTIAL, PGS_INDEXONLYSCAN, PGS_INDEXSCAN, root, Path::rows, RTE_RELATION, Path::startup_cost, and Path::total_cost.
Referenced by create_index_path(), and reparameterize_path().
◆ cost_material()
|
extern |
Definition at line 2582 of file costsize.c.
2586{
2591
2593 path->parent != NULL &&
2594 (path->parent->pgs_mask & PGS_CONSIDER_NONPARTIAL) == 0)
2595 enabled = false;
2596
2597 path->rows = tuples;
2598
2599 /*
2600 * Whether spilling or not, charge 2x cpu_operator_cost per tuple to
2601 * reflect bookkeeping overhead. (This rate must be more than what
2602 * cost_rescan charges for materialize, ie, cpu_operator_cost per tuple;
2603 * if it is exactly the same then there will be a cost tie between
2604 * nestloop with A outer, materialized B inner and nestloop with B outer,
2605 * materialized A inner. The extra cost ensures we'll prefer
2606 * materializing the smaller rel.) Note that this is normally a good deal
2607 * less than cpu_tuple_cost; which is OK because a Material plan node
2608 * doesn't do qual-checking or projection, so it's got less overhead than
2609 * most plan nodes.
2610 */
2611 run_cost += 2 * cpu_operator_cost * tuples;
2612
2613 /*
2614 * If we will spill to disk, charge at the rate of seq_page_cost per page.
2615 * This cost is assumed to be evenly spread through the plan run phase,
2616 * which isn't exactly accurate but our cost model doesn't allow for
2617 * nonuniform costs within the run phase.
2618 */
2620 {
2622
2623 run_cost += seq_page_cost * npages;
2624 }
2625
2627 path->startup_cost = startup_cost;
2628 path->total_cost = startup_cost + run_cost;
2629}
References cpu_operator_cost, Path::disabled_nodes, fb(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, 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()
|
extern |
Definition at line 2524 of file costsize.c.
2529{
2530 RelOptInfo *rel = path->parent;
2531 Cost startup_cost = 0;
2532 Cost run_cost = 0;
2534 double N;
2537
2540
2541 /*
2542 * Avoid log(0)...
2543 */
2546
2547 /* Assumed cost per tuple comparison */
2549
2550 /* Heap creation cost */
2552
2553 /* Per-tuple heap maintenance cost */
2555
2556 /*
2557 * Although MergeAppend does not do any selection or projection, it's not
2558 * free; add a small per-tuple overhead.
2559 */
2561
2562 path->disabled_nodes =
2567}
References APPEND_CPU_COST_MULTIPLIER, cpu_operator_cost, cpu_tuple_cost, Path::disabled_nodes, fb(), LOG2, Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, RelOptInfo::pgs_mask, PGS_MERGE_APPEND, Path::startup_cost, and Path::total_cost.
Referenced by create_merge_append_path().
◆ cost_namedtuplestorescan()
|
extern |
Definition at line 1790 of file costsize.c.
1792{
1793 Cost startup_cost = 0;
1794 Cost run_cost = 0;
1798
1799 /* Should only be applied to base relations that are Tuplestores */
1802
1803 /* Mark the path with the correct row estimate */
1806 else
1808
1809 /* Charge one CPU tuple cost per row for tuplestore manipulation */
1811
1812 /* Add scanning CPU costs */
1814
1815 startup_cost += qpqual_cost.startup;
1818
1821 path->disabled_nodes =
1823 path->startup_cost = startup_cost;
1824 path->total_cost = startup_cost + run_cost;
1825}
References Assert, cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_NAMEDTUPLESTORE, Path::startup_cost, and Path::total_cost.
Referenced by create_namedtuplestorescan_path().
◆ cost_qual_eval()
|
extern |
Definition at line 4903 of file costsize.c.
4904{
4905 cost_qual_eval_context context;
4906 ListCell *l;
4907
4911
4912 /* We don't charge any cost for the implicit ANDing at top level ... */
4913
4914 foreach(l, quals)
4915 {
4917
4918 cost_qual_eval_walker(qual, &context);
4919 }
4920
4921 *cost = context.total;
4922}
static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
Definition costsize.c:4943
Definition costsize.c:168
References cost_qual_eval_walker(), lfirst, QualCost::per_tuple, cost_qual_eval_context::root, root, QualCost::startup, and cost_qual_eval_context::total.
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()
|
extern |
Definition at line 4929 of file costsize.c.
4930{
4931 cost_qual_eval_context context;
4932
4936
4937 cost_qual_eval_walker(qual, &context);
4938
4939 *cost = context.total;
4940}
References cost_qual_eval_walker(), QualCost::per_tuple, cost_qual_eval_context::root, root, QualCost::startup, and cost_qual_eval_context::total.
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()
Definition at line 1874 of file costsize.c.
1875{
1876 Cost startup_cost;
1877 Cost total_cost;
1880
1881 /* We probably have decent estimates for the non-recursive term */
1882 startup_cost = nrterm->startup_cost;
1883 total_cost = nrterm->total_cost;
1885
1886 /*
1887 * We arbitrarily assume that about 10 recursive iterations will be
1888 * needed, and that we've managed to get a good fix on the cost and output
1889 * size of each one of them. These are mighty shaky assumptions but it's
1890 * hard to see how to do better.
1891 */
1892 total_cost += 10 * rterm->total_cost;
1894
1895 /*
1896 * Also charge cpu_tuple_cost per row to account for the costs of
1897 * manipulating the tuplestores. (We don't worry about possible
1898 * spill-to-disk costs.)
1899 */
1901
1904 runion->disabled_nodes =
1906 runion->startup_cost = startup_cost;
1907 runion->total_cost = total_cost;
1910 rterm->pathtarget->width);
1911}
References cpu_tuple_cost, fb(), Max, and PGS_CONSIDER_NONPARTIAL.
Referenced by create_recursiveunion_path().
◆ cost_resultscan()
|
extern |
Definition at line 1832 of file costsize.c.
1834{
1835 Cost startup_cost = 0;
1836 Cost run_cost = 0;
1840
1841 /* Should only be applied to RTE_RESULT base relations */
1844
1845 /* Mark the path with the correct row estimate */
1848 else
1850
1851 /* We charge qual cost plus cpu_tuple_cost */
1853
1854 startup_cost += qpqual_cost.startup;
1857
1860 path->disabled_nodes =
1862 path->startup_cost = startup_cost;
1863 path->total_cost = startup_cost + run_cost;
1864}
References Assert, cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_RESULT, Path::startup_cost, and Path::total_cost.
Referenced by create_resultscan_path().
◆ cost_samplescan()
|
extern |
Definition at line 348 of file costsize.c.
350{
351 Cost startup_cost = 0;
352 Cost run_cost = 0;
357 spc_random_page_cost,
358 spc_page_cost;
362
363 /* Should only be applied to base relations with tablesample clauses */
370
371 /* Mark the path with the correct row estimate */
374 else
376
377 /* fetch estimated page cost for tablespace containing table */
379 &spc_random_page_cost,
380 &spc_seq_page_cost);
381
382 /* if NextSampleBlock is used, assume random access, else sequential */
384 spc_random_page_cost : spc_seq_page_cost;
385
386 /*
387 * disk costs (recall that baserel->pages has already been set to the
388 * number of pages the sampling method will visit)
389 */
391
392 /*
393 * CPU costs (recall that baserel->tuples has already been set to the
394 * number of tuples the sampling method will select). Note that we ignore
395 * execution cost of the TABLESAMPLE parameter expressions; they will be
396 * evaluated only once per scan, and in most usages they'll likely be
397 * simple constants anyway. We also don't charge anything for the
398 * calculations the sampling method might do internally.
399 */
401
402 startup_cost += qpqual_cost.startup;
405 /* tlist eval costs are paid per output row, not per tuple scanned */
406 startup_cost += path->pathtarget->cost.startup;
407 run_cost += path->pathtarget->cost.per_tuple * path->rows;
408
411
412 path->disabled_nodes =
414 path->startup_cost = startup_cost;
415 path->total_cost = startup_cost + run_cost;
416}
Definition parsenodes.h:1402
Definition tsmapi.h:57
References Assert, cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), get_tablespace_page_costs(), GetTsmRoutine(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, planner_rt_fetch, root, Path::rows, RTE_RELATION, Path::startup_cost, and Path::total_cost.
Referenced by create_samplescan_path().
◆ cost_seqscan()
|
extern |
Definition at line 269 of file costsize.c.
271{
272 Cost startup_cost = 0;
279
280 /* Should only be applied to base relations */
283
284 /* Mark the path with the correct row estimate */
287 else
289
290 /* fetch estimated page cost for tablespace containing table */
292 NULL,
293 &spc_seq_page_cost);
294
295 /*
296 * disk costs
297 */
299
300 /* CPU costs */
302
303 startup_cost += qpqual_cost.startup;
306 /* tlist eval costs are paid per output row, not per tuple scanned */
307 startup_cost += path->pathtarget->cost.startup;
309
310 /* Adjust costing for parallelism, if used. */
312 {
314
315 /* The CPU cost is divided among all the workers. */
317
318 /*
319 * It may be possible to amortize some of the I/O cost, but probably
320 * not very much, because most operating systems already do aggressive
321 * prefetching. For now, we assume that the disk run cost can't be
322 * amortized at all.
323 */
324
325 /*
326 * In the case of a parallel plan, the row count needs to represent
327 * the number of tuples processed per worker.
328 */
330 }
331 else
333
334 path->disabled_nodes =
336 path->startup_cost = startup_cost;
338}
References Assert, clamp_row_est(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_parallel_divisor(), get_restriction_qual_cost(), get_tablespace_page_costs(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, PGS_SEQSCAN, root, Path::rows, RTE_RELATION, Path::startup_cost, and Path::total_cost.
Referenced by create_seqscan_path().
◆ cost_sort()
|
extern |
Definition at line 2200 of file costsize.c.
2206{
2207 Cost startup_cost;
2208 Cost run_cost;
2209
2210 cost_tuplesort(&startup_cost, &run_cost,
2211 tuples, width,
2213 limit_tuples);
2214
2215 startup_cost += input_cost;
2216
2217 /*
2218 * We can ignore PGS_CONSIDER_NONPARTIAL here, because if it's relevant,
2219 * it will have already affected the input path.
2220 */
2221 path->rows = tuples;
2223 path->startup_cost = startup_cost;
2224 path->total_cost = startup_cost + run_cost;
2225}
References cost_tuplesort(), Path::disabled_nodes, enable_sort, fb(), Path::rows, Path::startup_cost, and Path::total_cost.
Referenced by adjust_foreign_grouping_path_cost(), cost_append(), create_groupingsets_path(), create_merge_append_path(), create_sort_path(), initial_cost_mergejoin(), label_sort_with_costsize(), and plan_cluster_use_sort().
◆ cost_subplan()
|
extern |
Definition at line 4681 of file costsize.c.
4682{
4684
4685 /*
4686 * Figure any cost for evaluating the testexpr.
4687 *
4688 * Usually, SubPlan nodes are built very early, before we have constructed
4689 * any RelOptInfos for the parent query level, which means the parent root
4690 * does not yet contain enough information to safely consult statistics.
4691 * Therefore, we pass root as NULL here. cost_qual_eval() is already
4692 * well-equipped to handle a NULL root.
4693 *
4694 * One exception is SubPlan nodes built for the initplans of MIN/MAX
4695 * aggregates from indexes (cf. SS_make_initplan_from_plan). In this
4696 * case, having a NULL root is safe because testexpr will be NULL.
4697 * Besides, an initplan will by definition not consult anything from the
4698 * parent plan.
4699 */
4702 NULL);
4703
4705 {
4706 /*
4707 * If we are using a hash table for the subquery outputs, then the
4708 * cost of evaluating the query is a one-time cost. We charge one
4709 * cpu_operator_cost per tuple for the work of loading the hashtable,
4710 * too.
4711 */
4714
4715 /*
4716 * The per-tuple costs include the cost of evaluating the lefthand
4717 * expressions, plus the cost of probing the hashtable. We already
4718 * accounted for the lefthand expressions as part of the testexpr, and
4719 * will also have counted one cpu_operator_cost for each comparison
4720 * operator. That is probably too low for the probing cost, but it's
4721 * hard to make a better estimate, so live with it for now.
4722 */
4723 }
4724 else
4725 {
4726 /*
4727 * Otherwise we will be rescanning the subplan output on each
4728 * evaluation. We need to estimate how much of the output we will
4729 * actually need to scan. NOTE: this logic should agree with the
4730 * tuple_fraction estimates used by make_subplan() in
4731 * plan/subselect.c.
4732 */
4734
4736 {
4737 /* we only need to fetch 1 tuple; clamp to avoid zero divide */
4739 }
4742 {
4743 /* assume we need 50% of the tuples */
4745 /* also charge a cpu_operator_cost per row examined */
4747 }
4748 else
4749 {
4750 /* assume we need all tuples */
4752 }
4753
4754 /*
4755 * Also account for subplan's startup cost. If the subplan is
4756 * uncorrelated or undirect correlated, AND its topmost node is one
4757 * that materializes its output, assume that we'll only need to pay
4758 * its startup cost once; otherwise assume we pay the startup cost
4759 * every time.
4760 */
4764 else
4766 }
4767
4770}
Definition primnodes.h:189
References ALL_SUBLINK, ANY_SUBLINK, clamp_row_est(), cost_qual_eval(), cpu_operator_cost, ExecMaterializesOutput(), EXISTS_SUBLINK, fb(), make_ands_implicit(), NIL, nodeTag, SubPlan::parParam, SubPlan::per_call_cost, plan, 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()
|
extern |
Definition at line 1477 of file costsize.c.
1480{
1481 Cost startup_cost;
1482 Cost run_cost;
1487
1488 /* Should only be applied to base relations that are subqueries */
1491
1492 /*
1493 * We compute the rowcount estimate as the subplan's estimate times the
1494 * selectivity of relevant restriction clauses. In simple cases this will
1495 * come out the same as baserel->rows; but when dealing with parallelized
1496 * paths we must do it like this to get the right answer.
1497 */
1500 baserel->baserestrictinfo);
1501 else
1503
1506 qpquals,
1507 0,
1508 JOIN_INNER,
1509 NULL));
1510
1511 /*
1512 * Cost of path is cost of evaluating the subplan, plus cost of evaluating
1513 * any restriction clauses and tlist that will be attached to the
1514 * SubqueryScan node, plus cpu_tuple_cost to account for selection and
1515 * projection overhead.
1516 */
1523
1524 /*
1525 * However, if there are no relevant restriction clauses and the
1526 * pathtarget is trivial, then we expect that setrefs.c will optimize away
1527 * the SubqueryScan plan node altogether, so we should just make its cost
1528 * and rowcount equal to the input path's.
1529 *
1530 * Note: there are some edge cases where createplan.c will apply a
1531 * different targetlist to the SubqueryScan node, thus falsifying our
1532 * current estimate of whether the target is trivial, and making the cost
1533 * estimate (though not the rowcount) wrong. It does not seem worth the
1534 * extra complication to try to account for that exactly, especially since
1535 * that behavior falsifies other cost estimates as well.
1536 */
1538 return;
1539
1541
1542 startup_cost = qpqual_cost.startup;
1545
1546 /* tlist eval costs are paid per output row, not per tuple scanned */
1547 startup_cost += path->path.pathtarget->cost.startup;
1549
1552}
References Assert, clamp_row_est(), clauselist_selectivity(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), JOIN_INNER, list_concat_copy(), NIL, Path::parallel_workers, SubqueryScanPath::path, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_SUBQUERY, Path::startup_cost, SubqueryScanPath::subpath, and Path::total_cost.
Referenced by create_subqueryscan_path().
◆ cost_tablefuncscan()
|
extern |
Definition at line 1628 of file costsize.c.
1630{
1631 Cost startup_cost = 0;
1632 Cost run_cost = 0;
1638
1639 /* Should only be applied to base relations that are functions */
1643
1644 /* Mark the path with the correct row estimate */
1647 else
1649
1650 /*
1651 * Estimate costs of executing the table func expression(s).
1652 *
1653 * XXX in principle we ought to charge tuplestore spill costs if the
1654 * number of rows is large. However, given how phony our rowcount
1655 * estimates for tablefuncs tend to be, there's not a lot of point in that
1656 * refinement right now.
1657 */
1659
1661
1662 /* Add scanning CPU costs */
1664
1665 startup_cost += qpqual_cost.startup;
1668
1669 /* tlist eval costs are paid per output row, not per tuple scanned */
1670 startup_cost += path->pathtarget->cost.startup;
1671 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1672
1675 path->disabled_nodes =
1677 path->startup_cost = startup_cost;
1678 path->total_cost = startup_cost + run_cost;
1679}
References Assert, cost_qual_eval_node(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, planner_rt_fetch, root, Path::rows, RTE_TABLEFUNC, Path::startup_cost, and Path::total_cost.
Referenced by create_tablefuncscan_path().
◆ cost_tidrangescan()
|
extern |
Definition at line 1360 of file costsize.c.
1363{
1364 Selectivity selectivity;
1365 double pages;
1366 Cost startup_cost;
1372 double ntuples;
1374 double spc_random_page_cost;
1377
1378 /* Should only be applied to base relations */
1381
1382 /* Mark the path with the correct row estimate */
1385 else
1387
1388 /* Count how many tuples and pages we expect to scan */
1392
1393 if (pages <= 0.0)
1394 pages = 1.0;
1395
1396 /*
1397 * The first page in a range requires a random seek, but each subsequent
1398 * page is just a normal sequential page read. NOTE: it's desirable for
1399 * TID Range Scans to cost more than the equivalent Sequential Scans,
1400 * because Seq Scans have some performance advantages such as scan
1401 * synchronization, and we'd prefer one of them to be picked unless a TID
1402 * Range Scan really is better.
1403 */
1404 ntuples = selectivity * baserel->tuples;
1405 nseqpages = pages - 1.0;
1406
1407 /*
1408 * The TID qual expressions will be computed once, any other baserestrict
1409 * quals once per retrieved tuple.
1410 */
1412
1413 /* fetch estimated page cost for tablespace containing table */
1415 &spc_random_page_cost,
1416 &spc_seq_page_cost);
1417
1418 /* disk costs; 1 random page and the remainder as seq pages */
1420
1421 /* Add scanning CPU costs */
1423
1424 /*
1425 * XXX currently we assume TID quals are a subset of qpquals at this
1426 * point; they will be removed (if possible) when we create the plan, so
1427 * we subtract their cost from the total qpqual cost. (If the TID quals
1428 * can't be removed, this is a mistake and we're going to underestimate
1429 * the CPU cost a bit.)
1430 */
1433 tid_qual_cost.per_tuple;
1435
1436 /* tlist eval costs are paid per output row, not per tuple scanned */
1437 startup_cost += path->pathtarget->cost.startup;
1439
1440 /* Adjust costing for parallelism, if used. */
1442 {
1444
1445 /* The CPU cost is divided among all the workers. */
1447
1448 /*
1449 * In the case of a parallel plan, the row count needs to represent
1450 * the number of tuples processed per worker.
1451 */
1453 }
1454
1455 /*
1456 * We should not generate this path type when PGS_TIDSCAN is unset, but we
1457 * might need to disable this path due to PGS_CONSIDER_NONPARTIAL.
1458 */
1462 path->disabled_nodes =
1464 path->startup_cost = startup_cost;
1466}
References Assert, clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), cpu_tuple_cost, Path::disabled_nodes, fb(), get_parallel_divisor(), get_restriction_qual_cost(), get_tablespace_page_costs(), JOIN_INNER, Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, PGS_TIDSCAN, root, Path::rows, RTE_RELATION, Path::startup_cost, and Path::total_cost.
Referenced by create_tidrangescan_path().
◆ cost_tidscan()
|
extern |
Definition at line 1250 of file costsize.c.
1252{
1253 Cost startup_cost = 0;
1254 Cost run_cost = 0;
1258 double ntuples;
1259 ListCell *l;
1260 double spc_random_page_cost;
1262
1263 /* Should only be applied to base relations */
1267
1268 /* Mark the path with the correct row estimate */
1271 else
1273
1274 /* Count how many tuples we expect to retrieve */
1275 ntuples = 0;
1276 foreach(l, tidquals)
1277 {
1280
1281 /*
1282 * We must use a TID scan for CurrentOfExpr; in any other case, we
1283 * should be generating a TID scan only if TID scans are allowed.
1284 * Also, if CurrentOfExpr is the qual, there should be only one.
1285 */
1288
1290 {
1291 /* Each element of the array yields 1 tuple */
1294
1296 }
1298 {
1299 /* CURRENT OF yields 1 tuple */
1300 ntuples++;
1301 }
1302 else
1303 {
1304 /* It's just CTID = something, count 1 tuple */
1305 ntuples++;
1306 }
1307 }
1308
1309 /*
1310 * The TID qual expressions will be computed once, any other baserestrict
1311 * quals once per retrieved tuple.
1312 */
1314
1315 /* fetch estimated page cost for tablespace containing table */
1317 &spc_random_page_cost,
1318 NULL);
1319
1320 /* disk costs --- assume each tuple on a different page */
1321 run_cost += spc_random_page_cost * ntuples;
1322
1323 /* Add scanning CPU costs */
1325
1326 /* XXX currently we assume TID quals are a subset of qpquals */
1329 tid_qual_cost.per_tuple;
1330 run_cost += cpu_per_tuple * ntuples;
1331
1332 /* tlist eval costs are paid per output row, not per tuple scanned */
1333 startup_cost += path->pathtarget->cost.startup;
1334 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1335
1336 /*
1337 * There are assertions above verifying that we only reach this function
1338 * either when baserel->pgs_mask includes PGS_TIDSCAN or when the TID scan
1339 * is the only legal path, so we only need to consider the effects of
1340 * PGS_CONSIDER_NONPARTIAL here.
1341 */
1344 path->disabled_nodes =
1346 path->startup_cost = startup_cost;
1347 path->total_cost = startup_cost + run_cost;
1348}
double estimate_array_length(PlannerInfo *root, Node *arrayexpr)
Definition selfuncs.c:2223
Definition primnodes.h:2120
Definition primnodes.h:926
References ScalarArrayOpExpr::args, Assert, RestrictInfo::clause, cost_qual_eval(), cpu_tuple_cost, Path::disabled_nodes, estimate_array_length(), fb(), get_restriction_qual_cost(), get_tablespace_page_costs(), IsA, lfirst_node, list_length(), lsecond, NIL, Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, PGS_TIDSCAN, root, Path::rows, RTE_RELATION, Path::startup_cost, and Path::total_cost.
Referenced by create_tidscan_path().
◆ cost_valuesscan()
|
extern |
Definition at line 1689 of file costsize.c.
1691{
1692 Cost startup_cost = 0;
1693 Cost run_cost = 0;
1697
1698 /* Should only be applied to base relations that are values lists */
1701
1702 /* Mark the path with the correct row estimate */
1705 else
1707
1708 /*
1709 * For now, estimate list evaluation cost at one operator eval per list
1710 * (probably pretty bogus, but is it worth being smarter?)
1711 */
1713
1714 /* Add scanning CPU costs */
1716
1717 startup_cost += qpqual_cost.startup;
1720
1721 /* tlist eval costs are paid per output row, not per tuple scanned */
1722 startup_cost += path->pathtarget->cost.startup;
1723 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1724
1727 path->disabled_nodes =
1729 path->startup_cost = startup_cost;
1730 path->total_cost = startup_cost + run_cost;
1731}
References Assert, cpu_operator_cost, cpu_tuple_cost, Path::disabled_nodes, fb(), get_restriction_qual_cost(), Path::parallel_workers, PGS_CONSIDER_NONPARTIAL, root, Path::rows, RTE_VALUES, Path::startup_cost, and Path::total_cost.
Referenced by create_valuesscan_path().
◆ cost_windowagg()
|
extern |
Definition at line 3208 of file costsize.c.
3213{
3214 Cost startup_cost;
3215 Cost total_cost;
3220
3223
3224 startup_cost = input_startup_cost;
3225 total_cost = input_total_cost;
3226
3227 /*
3228 * Window functions are assumed to cost their stated execution cost, plus
3229 * the cost of evaluating their input expressions, per tuple. Since they
3230 * may in fact evaluate their inputs at multiple rows during each cycle,
3231 * this could be a drastic underestimate; but without a way to know how
3232 * many rows the window function will fetch, it's hard to do better. In
3233 * any case, it's a good estimate for all the built-in window functions,
3234 * so we'll just do this for now.
3235 */
3237 {
3241
3244 &argcosts);
3245 startup_cost += argcosts.startup;
3247
3248 /* also add the input expressions' cost to per-input-row costs */
3250 startup_cost += argcosts.startup;
3252
3253 /*
3254 * Add the filter's cost to per-input-row costs. XXX We should reduce
3255 * input expression costs according to filter selectivity.
3256 */
3258 startup_cost += argcosts.startup;
3260
3261 total_cost += wfunccost * input_tuples;
3262 }
3263
3264 /*
3265 * We also charge cpu_operator_cost per grouping column per tuple for
3266 * grouping comparisons, plus cpu_tuple_cost per tuple for general
3267 * overhead.
3268 *
3269 * XXX this neglects costs of spooling the data to disk when it overflows
3270 * work_mem. Sooner or later that should get accounted for.
3271 */
3273 total_cost += cpu_tuple_cost * input_tuples;
3274
3275 path->rows = input_tuples;
3277 path->startup_cost = startup_cost;
3278 path->total_cost = total_cost;
3279
3280 /*
3281 * Also, take into account how many tuples we need to read from the
3282 * subnode in order to produce the first tuple from the WindowAgg. To do
3283 * this we proportion the run cost (total cost not including startup cost)
3284 * over the estimated startup tuples. We already included the startup
3285 * cost of the subnode, so we only need to do this when the estimated
3286 * startup tuples is above 1.0.
3287 */
3289 input_tuples);
3290
3292 path->startup_cost += (total_cost - startup_cost) / input_tuples *
3293 (startup_tuples - 1.0);
3294}
static double get_windowclause_startup_tuples(PlannerInfo *root, WindowClause *wc, double input_tuples)
Definition costsize.c:2994
void add_function_cost(PlannerInfo *root, Oid funcid, Node *node, QualCost *cost)
Definition plancat.c:2360
Definition primnodes.h:594
References add_function_cost(), WindowFunc::aggfilter, WindowFunc::args, cost_qual_eval_node(), cpu_operator_cost, cpu_tuple_cost, Path::disabled_nodes, fb(), get_windowclause_startup_tuples(), lfirst_node, list_length(), WindowClause::orderClause, WindowClause::partitionClause, root, Path::rows, QualCost::startup, Path::startup_cost, Path::total_cost, and WindowFunc::winfnoid.
Referenced by create_windowagg_path().
◆ final_cost_hashjoin()
|
extern |
Definition at line 4420 of file costsize.c.
4423{
4442
4443 /* Set the number of disabled nodes. */
4445
4446 /* Mark the path with the correct row estimate */
4449 else
4451
4452 /* For partial paths, scale row estimate. */
4454 {
4456
4457 path->jpath.path.rows =
4459 }
4460
4461 /* mark the path with estimated # of batches */
4462 path->num_batches = numbatches;
4463
4464 /* store the total number of tuples (sum of partial row estimates) */
4466
4467 /* and compute the number of "virtual" buckets in the whole join */
4469
4470 /*
4471 * Determine bucketsize fraction and MCV frequency for the inner relation.
4472 * We use the smallest bucketsize or MCV frequency estimated for any
4473 * individual hashclause; this is undoubtedly conservative.
4474 *
4475 * BUT: if inner relation has been unique-ified, we can assume it's good
4476 * for hashing. This is important both because it's the right answer, and
4477 * because we avoid contaminating the cache with a value that's wrong for
4478 * non-unique-ified paths.
4479 */
4482 {
4485 }
4486 else
4487 {
4489
4490 innerbucketsize = 1.0;
4491 innermcvfreq = 1.0;
4492
4493 /* At first, try to estimate bucket size using extended statistics. */
4495 inner_path->parent,
4496 hashclauses,
4497 &innerbucketsize);
4498
4499 /* Pass through the remaining clauses */
4501 {
4505
4506 /*
4507 * First we have to figure out which side of the hashjoin clause
4508 * is the inner side.
4509 *
4510 * Since we tend to visit the same clauses over and over when
4511 * planning a large query, we cache the bucket stats estimates in
4512 * the RestrictInfo node to avoid repeated lookups of statistics.
4513 */
4515 inner_path->parent->relids))
4516 {
4517 /* righthand side is inner */
4520 {
4521 /* not cached yet */
4524 virtualbuckets,
4525 &restrictinfo->right_mcvfreq,
4526 &restrictinfo->right_bucketsize);
4528 }
4530 }
4531 else
4532 {
4534 inner_path->parent->relids));
4535 /* lefthand side is inner */
4538 {
4539 /* not cached yet */
4542 virtualbuckets,
4543 &restrictinfo->left_mcvfreq,
4544 &restrictinfo->left_bucketsize);
4546 }
4548 }
4549
4552 /* Disregard zero for MCV freq, it means we have no data */
4555 }
4556 }
4557
4558 /*
4559 * If the bucket holding the inner MCV would exceed hash_mem, we don't
4560 * want to hash unless there is really no other alternative, so apply
4561 * disable_cost. (The executor normally copes with excessive memory usage
4562 * by splitting batches, but obviously it cannot separate equal values
4563 * that way, so it will be unable to drive the batch size below hash_mem
4564 * when this is true.)
4565 */
4568 startup_cost += disable_cost;
4569
4570 /*
4571 * Compute cost of the hashquals and qpquals (other restriction clauses)
4572 * separately.
4573 */
4578
4579 /* CPU costs */
4580
4583 extra->inner_unique)
4584 {
4587
4588 /*
4589 * With a SEMI or ANTI join, or if the innerrel is known unique, the
4590 * executor will stop after the first match.
4591 *
4592 * For an outer-rel row that has at least one match, we can expect the
4593 * bucket scan to stop after a fraction 1/(match_count+1) of the
4594 * bucket's rows, if the matches are evenly distributed. Since they
4595 * probably aren't quite evenly distributed, we apply a fuzz factor of
4596 * 2.0 to that fraction. (If we used a larger fuzz factor, we'd have
4597 * to clamp inner_scan_frac to at most 1.0; but since match_count is
4598 * at least 1, no such clamp is needed now.)
4599 */
4602
4603 startup_cost += hash_qual_cost.startup;
4606
4607 /*
4608 * For unmatched outer-rel rows, the picture is quite a lot different.
4609 * In the first place, there is no reason to assume that these rows
4610 * preferentially hit heavily-populated buckets; instead assume they
4611 * are uncorrelated with the inner distribution and so they see an
4612 * average bucket size of inner_path_rows / virtualbuckets. In the
4613 * second place, it seems likely that they will have few if any exact
4614 * hash-code matches and so very few of the tuples in the bucket will
4615 * actually require eval of the hash quals. We don't have any good
4616 * way to estimate how many will, but for the moment assume that the
4617 * effective cost per bucket entry is one-tenth what it is for
4618 * matchable tuples.
4619 */
4620 run_cost += hash_qual_cost.per_tuple *
4623
4624 /* Get # of tuples that will pass the basic join */
4627 else
4629 }
4630 else
4631 {
4632 /*
4633 * The number of tuple comparisons needed is the number of outer
4634 * tuples times the typical number of tuples in a hash bucket, which
4635 * is the inner relation size times its bucketsize fraction. At each
4636 * one, we need to evaluate the hashjoin quals. But actually,
4637 * charging the full qual eval cost at each tuple is pessimistic,
4638 * since we don't evaluate the quals unless the hash values match
4639 * exactly. For lack of a better idea, halve the cost estimate to
4640 * allow for that.
4641 */
4642 startup_cost += hash_qual_cost.startup;
4645
4646 /*
4647 * Get approx # tuples passing the hashquals. We use
4648 * approx_tuple_count here because we need an estimate done with
4649 * JOIN_INNER semantics.
4650 */
4652 }
4653
4654 /*
4655 * For each tuple that gets through the hashjoin proper, we charge
4656 * cpu_tuple_cost plus the cost of evaluating additional restriction
4657 * clauses that are to be applied at the join. (This is pessimistic since
4658 * not all of the quals may get evaluated at each tuple.)
4659 */
4660 startup_cost += qp_qual_cost.startup;
4663
4664 /* tlist eval costs are paid per output row, not per tuple scanned */
4665 startup_cost += path->jpath.path.pathtarget->cost.startup;
4667
4668 path->jpath.path.startup_cost = startup_cost;
4669 path->jpath.path.total_cost = startup_cost + run_cost;
4670}
static double approx_tuple_count(PlannerInfo *root, JoinPath *path, List *quals)
Definition costsize.c:5451
#define RELATION_WAS_MADE_UNIQUE(rel, sjinfo, nominal_jointype)
Definition pathnodes.h:1232
List * estimate_multivariate_bucketsize(PlannerInfo *root, RelOptInfo *inner, List *hashclauses, Selectivity *innerbucketsize)
Definition selfuncs.c:4123
void estimate_hash_bucket_stats(PlannerInfo *root, Node *hashkey, double nbuckets, Selectivity *mcv_freq, Selectivity *bucketsize_frac)
Definition selfuncs.c:4390
References approx_tuple_count(), Assert, bms_is_subset(), clamp_row_est(), cost_qual_eval(), cpu_tuple_cost, disable_cost, JoinCostWorkspace::disabled_nodes, estimate_hash_bucket_stats(), estimate_multivariate_bucketsize(), fb(), get_hash_memory_limit(), get_leftop(), get_parallel_divisor(), get_rightop(), HashPath::inner_rows_total, JoinCostWorkspace::inner_rows_total, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, 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, relation_byte_size(), RELATION_WAS_MADE_UNIQUE, root, Path::rows, JoinCostWorkspace::run_cost, JoinPathExtraData::semifactors, JoinPathExtraData::sjinfo, and JoinCostWorkspace::startup_cost.
Referenced by create_hashjoin_path().
◆ final_cost_mergejoin()
|
extern |
Definition at line 3959 of file costsize.c.
3962{
3976 bare_inner_cost,
3977 mat_inner_cost;
3981 rescannedtuples;
3984
3985 /* Protect some assumptions below that rowcounts aren't zero */
3987 inner_path_rows = 1;
3988
3989 /* Mark the path with the correct row estimate */
3992 else
3994
3995 /* For partial paths, scale row estimate. */
3997 {
3999
4000 path->jpath.path.rows =
4002 }
4003
4004 /*
4005 * Compute cost of the mergequals and qpquals (other restriction clauses)
4006 * separately.
4007 */
4012
4013 /*
4014 * With a SEMI or ANTI join, or if the innerrel is known unique, the
4015 * executor will stop scanning for matches after the first match. When
4016 * all the joinclauses are merge clauses, this means we don't ever need to
4017 * back up the merge, and so we can skip mark/restore overhead.
4018 */
4021 extra->inner_unique) &&
4025 else
4027
4028 /*
4029 * Get approx # tuples passing the mergequals. We use approx_tuple_count
4030 * here because we need an estimate done with JOIN_INNER semantics.
4031 */
4033
4034 /*
4035 * When there are equal merge keys in the outer relation, the mergejoin
4036 * must rescan any matching tuples in the inner relation. This means
4037 * re-fetching inner tuples; we have to estimate how often that happens.
4038 *
4039 * For regular inner and outer joins, the number of re-fetches can be
4040 * estimated approximately as size of merge join output minus size of
4041 * inner relation. Assume that the distinct key values are 1, 2, ..., and
4042 * denote the number of values of each key in the outer relation as m1,
4043 * m2, ...; in the inner relation, n1, n2, ... Then we have
4044 *
4045 * size of join = m1 * n1 + m2 * n2 + ...
4046 *
4047 * number of rescanned tuples = (m1 - 1) * n1 + (m2 - 1) * n2 + ... = m1 *
4048 * n1 + m2 * n2 + ... - (n1 + n2 + ...) = size of join - size of inner
4049 * relation
4050 *
4051 * This equation works correctly for outer tuples having no inner match
4052 * (nk = 0), but not for inner tuples having no outer match (mk = 0); we
4053 * are effectively subtracting those from the number of rescanned tuples,
4054 * when we should not. Can we do better without expensive selectivity
4055 * computations?
4056 *
4057 * The whole issue is moot if we know we don't need to mark/restore at
4058 * all, or if we are working from a unique-ified outer input.
4059 */
4063 rescannedtuples = 0;
4064 else
4065 {
4067 /* Must clamp because of possible underestimate */
4069 rescannedtuples = 0;
4070 }
4071
4072 /*
4073 * We'll inflate various costs this much to account for rescanning. Note
4074 * that this is to be multiplied by something involving inner_rows, or
4075 * another number related to the portion of the inner rel we'll scan.
4076 */
4078
4079 /*
4080 * Decide whether we want to materialize the inner input to shield it from
4081 * mark/restore and performing re-fetches. Our cost model for regular
4082 * re-fetches is that a re-fetch costs the same as an original fetch,
4083 * which is probably an overestimate; but on the other hand we ignore the
4084 * bookkeeping costs of mark/restore. Not clear if it's worth developing
4085 * a more refined model. So we just need to inflate the inner run cost by
4086 * rescanratio.
4087 */
4089
4090 /*
4091 * When we interpose a Material node the re-fetch cost is assumed to be
4092 * just cpu_operator_cost per tuple, independently of the underlying
4093 * plan's cost; and we charge an extra cpu_operator_cost per original
4094 * fetch as well. Note that we're assuming the materialize node will
4095 * never spill to disk, since it only has to remember tuples back to the
4096 * last mark. (If there are a huge number of duplicates, our other cost
4097 * factors will make the path so expensive that it probably won't get
4098 * chosen anyway.) So we don't use cost_rescan here.
4099 *
4100 * Note: keep this estimate in sync with create_mergejoin_plan's labeling
4101 * of the generated Material node.
4102 */
4103 mat_inner_cost = inner_run_cost +
4105
4106 /*
4107 * If we don't need mark/restore at all, we don't need materialization.
4108 */
4111
4112 /*
4113 * If merge joins with materialization are enabled, then choose
4114 * materialization if either (a) it looks cheaper or (b) merge joins
4115 * without materialization are disabled.
4116 */
4121
4122 /*
4123 * Regardless of what plan shapes are enabled and what the costs seem to
4124 * be, we *must* materialize it if the inner path is to be used directly
4125 * (without sorting) and it doesn't support mark/restore. Planner failure
4126 * is not an option!
4127 *
4128 * Since the inner side must be ordered, and only Sorts and IndexScans can
4129 * create order to begin with, and they both support mark/restore, you
4130 * might think there's no problem --- but you'd be wrong. Nestloop and
4131 * merge joins can *preserve* the order of their inputs, so they can be
4132 * selected as the input of a mergejoin, and they don't support
4133 * mark/restore at present.
4134 */
4138
4139 /*
4140 * Also, force materializing if the inner path is to be sorted and the
4141 * sort is expected to spill to disk. This is because the final merge
4142 * pass can be done on-the-fly if it doesn't have to support mark/restore.
4143 * We don't try to adjust the cost estimates for this consideration,
4144 * though.
4145 *
4146 * Since materialization is a performance optimization in this case,
4147 * rather than necessary for correctness, we skip it if materialization is
4148 * switched off.
4149 */
4151 innersortkeys != NIL &&
4153 inner_path->pathtarget->width) >
4156 else
4158
4159 /* Get the number of disabled nodes, not yet including this one. */
4161
4162 /*
4163 * Charge the right incremental cost for the chosen case, and update
4164 * enable_mask as appropriate.
4165 */
4167 {
4168 run_cost += mat_inner_cost;
4170 }
4171 else
4172 {
4173 run_cost += bare_inner_cost;
4175 }
4176
4177 /* Incremental count of disabled nodes if this node is disabled. */
4181 ++path->jpath.path.disabled_nodes;
4182
4183 /* CPU costs */
4184
4185 /*
4186 * The number of tuple comparisons needed is approximately number of outer
4187 * rows plus number of inner rows plus number of rescanned tuples (can we
4188 * refine this?). At each one, we need to evaluate the mergejoin quals.
4189 */
4190 startup_cost += merge_qual_cost.startup;
4191 startup_cost += merge_qual_cost.per_tuple *
4192 (outer_skip_rows + inner_skip_rows * rescanratio);
4193 run_cost += merge_qual_cost.per_tuple *
4194 ((outer_rows - outer_skip_rows) +
4195 (inner_rows - inner_skip_rows) * rescanratio);
4196
4197 /*
4198 * For each tuple that gets through the mergejoin proper, we charge
4199 * cpu_tuple_cost plus the cost of evaluating additional restriction
4200 * clauses that are to be applied at the join. (This is pessimistic since
4201 * not all of the quals may get evaluated at each tuple.)
4202 *
4203 * Note: we could adjust for SEMI/ANTI joins skipping some qual
4204 * evaluations here, but it's probably not worth the trouble.
4205 */
4206 startup_cost += qp_qual_cost.startup;
4209
4210 /* tlist eval costs are paid per output row, not per tuple scanned */
4211 startup_cost += path->jpath.path.pathtarget->cost.startup;
4213
4214 path->jpath.path.startup_cost = startup_cost;
4215 path->jpath.path.total_cost = startup_cost + run_cost;
4216}
References approx_tuple_count(), clamp_row_est(), cost_qual_eval(), cpu_operator_cost, cpu_tuple_cost, JoinCostWorkspace::disabled_nodes, ExecSupportsMarkRestore(), fb(), get_parallel_divisor(), JoinCostWorkspace::inner_rows, JoinCostWorkspace::inner_run_cost, JoinCostWorkspace::inner_skip_rows, JoinPathExtraData::inner_unique, JoinPath::innerjoinpath, MergePath::innersortkeys, 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, PGS_CONSIDER_NONPARTIAL, JoinPathExtraData::pgs_mask, PGS_MERGEJOIN_MATERIALIZE, PGS_MERGEJOIN_PLAIN, relation_byte_size(), RELATION_WAS_MADE_UNIQUE, root, Path::rows, JoinCostWorkspace::run_cost, JoinPathExtraData::sjinfo, MergePath::skip_mark_restore, JoinCostWorkspace::startup_cost, and work_mem.
Referenced by create_mergejoin_path().
◆ final_cost_nestloop()
|
extern |
Definition at line 3459 of file costsize.c.
3462{
3471 double ntuples;
3472
3473 /* Set the number of disabled nodes. */
3475
3476 /* Protect some assumptions below that rowcounts aren't zero */
3478 outer_path_rows = 1;
3480 inner_path_rows = 1;
3481 /* Mark the path with the correct row estimate */
3484 else
3486
3487 /* For partial paths, scale row estimate. */
3489 {
3491
3492 path->jpath.path.rows =
3494 }
3495
3496 /* cost of inner-relation source data (we already dealt with outer rel) */
3497
3499 extra->inner_unique)
3500 {
3501 /*
3502 * With a SEMI or ANTI join, or if the innerrel is known unique, the
3503 * executor will stop after the first match.
3504 */
3510
3511 /*
3512 * For an outer-rel row that has at least one match, we can expect the
3513 * inner scan to stop after a fraction 1/(match_count+1) of the inner
3514 * rows, if the matches are evenly distributed. Since they probably
3515 * aren't quite evenly distributed, we apply a fuzz factor of 2.0 to
3516 * that fraction. (If we used a larger fuzz factor, we'd have to
3517 * clamp inner_scan_frac to at most 1.0; but since match_count is at
3518 * least 1, no such clamp is needed now.)
3519 */
3523
3524 /*
3525 * Compute number of tuples processed (not number emitted!). First,
3526 * account for successfully-matched outer rows.
3527 */
3529
3530 /*
3531 * Now we need to estimate the actual costs of scanning the inner
3532 * relation, which may be quite a bit less than N times inner_run_cost
3533 * due to early scan stops. We consider two cases. If the inner path
3534 * is an indexscan using all the joinquals as indexquals, then an
3535 * unmatched outer row results in an indexscan returning no rows,
3536 * which is probably quite cheap. Otherwise, the executor will have
3537 * to scan the whole inner rel for an unmatched row; not so cheap.
3538 */
3540 {
3541 /*
3542 * Successfully-matched outer rows will only require scanning
3543 * inner_scan_frac of the inner relation. In this case, we don't
3544 * need to charge the full inner_run_cost even when that's more
3545 * than inner_rescan_run_cost, because we can assume that none of
3546 * the inner scans ever scan the whole inner relation. So it's
3547 * okay to assume that all the inner scan executions can be
3548 * fractions of the full cost, even if materialization is reducing
3549 * the rescan cost. At this writing, it's impossible to get here
3550 * for a materialized inner scan, so inner_run_cost and
3551 * inner_rescan_run_cost will be the same anyway; but just in
3552 * case, use inner_run_cost for the first matched tuple and
3553 * inner_rescan_run_cost for additional ones.
3554 */
3555 run_cost += inner_run_cost * inner_scan_frac;
3558
3559 /*
3560 * Add the cost of inner-scan executions for unmatched outer rows.
3561 * We estimate this as the same cost as returning the first tuple
3562 * of a nonempty scan. We consider that these are all rescans,
3563 * since we used inner_run_cost once already.
3564 */
3565 run_cost += outer_unmatched_rows *
3566 inner_rescan_run_cost / inner_path_rows;
3567
3568 /*
3569 * We won't be evaluating any quals at all for unmatched rows, so
3570 * don't add them to ntuples.
3571 */
3572 }
3573 else
3574 {
3575 /*
3576 * Here, a complicating factor is that rescans may be cheaper than
3577 * first scans. If we never scan all the way to the end of the
3578 * inner rel, it might be (depending on the plan type) that we'd
3579 * never pay the whole inner first-scan run cost. However it is
3580 * difficult to estimate whether that will happen (and it could
3581 * not happen if there are any unmatched outer rows!), so be
3582 * conservative and always charge the whole first-scan cost once.
3583 * We consider this charge to correspond to the first unmatched
3584 * outer row, unless there isn't one in our estimate, in which
3585 * case blame it on the first matched row.
3586 */
3587
3588 /* First, count all unmatched join tuples as being processed */
3590
3591 /* Now add the forced full scan, and decrement appropriate count */
3592 run_cost += inner_run_cost;
3594 outer_unmatched_rows -= 1;
3595 else
3596 outer_matched_rows -= 1;
3597
3598 /* Add inner run cost for additional outer tuples having matches */
3601
3602 /* Add inner run cost for additional unmatched outer tuples */
3604 run_cost += outer_unmatched_rows * inner_rescan_run_cost;
3605 }
3606 }
3607 else
3608 {
3609 /* Normal-case source costs were included in preliminary estimate */
3610
3611 /* Compute number of tuples processed (not number emitted!) */
3613 }
3614
3615 /* CPU costs */
3617 startup_cost += restrict_qual_cost.startup;
3619 run_cost += cpu_per_tuple * ntuples;
3620
3621 /* tlist eval costs are paid per output row, not per tuple scanned */
3622 startup_cost += path->jpath.path.pathtarget->cost.startup;
3624
3625 path->jpath.path.startup_cost = startup_cost;
3626 path->jpath.path.total_cost = startup_cost + run_cost;
3627}
References clamp_row_est(), cost_qual_eval(), cpu_tuple_cost, JoinCostWorkspace::disabled_nodes, fb(), 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, root, Path::rows, JoinCostWorkspace::run_cost, JoinPathExtraData::semifactors, and JoinCostWorkspace::startup_cost.
Referenced by create_nestloop_path().
◆ get_parameterized_baserel_size()
|
extern |
Definition at line 5526 of file costsize.c.
5528{
5530 double nrows;
5531
5532 /*
5533 * Estimate the number of rows returned by the parameterized scan, knowing
5534 * that it will apply all the extra join clauses as well as the rel's own
5535 * restriction clauses. Note that we force the clauses to be treated as
5536 * non-join clauses during selectivity estimation.
5537 */
5539 nrows = rel->tuples *
5541 allclauses,
5543 JOIN_INNER,
5544 NULL);
5545 nrows = clamp_row_est(nrows);
5546 /* For safety, make sure result is not more than the base estimate */
5548 nrows = rel->rows;
5549 return nrows;
5550}
References RelOptInfo::baserestrictinfo, clamp_row_est(), clauselist_selectivity(), fb(), JOIN_INNER, list_concat_copy(), RelOptInfo::relid, root, RelOptInfo::rows, and RelOptInfo::tuples.
Referenced by get_baserel_parampathinfo().
◆ get_parameterized_joinrel_size()
|
extern |
Definition at line 5607 of file costsize.c.
5612{
5613 double nrows;
5614
5615 /*
5616 * Estimate the number of rows returned by the parameterized join as the
5617 * sizes of the input paths times the selectivity of the clauses that have
5618 * ended up at this join node.
5619 *
5620 * As with set_joinrel_size_estimates, the rowcount estimate could depend
5621 * on the pair of input paths provided, though ideally we'd get the same
5622 * estimate for any pair with the same parameterization.
5623 */
5625 rel,
5626 outer_path->parent,
5627 inner_path->parent,
5628 outer_path->rows,
5629 inner_path->rows,
5630 sjinfo,
5631 restrict_clauses);
5632 /* For safety, make sure result is not more than the base estimate */
5634 nrows = rel->rows;
5635 return nrows;
5636}
static double calc_joinrel_size_estimate(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outer_rel, RelOptInfo *inner_rel, double outer_rows, double inner_rows, SpecialJoinInfo *sjinfo, List *restrictlist)
Definition costsize.c:5648
References calc_joinrel_size_estimate(), fb(), root, and RelOptInfo::rows.
Referenced by get_joinrel_parampathinfo().
◆ index_pages_fetched()
|
extern |
Definition at line 896 of file costsize.c.
898{
902 b;
903
904 /* T is # pages in table, but don't allow it to be zero */
906
907 /* Compute number of pages assumed to be competing for cache space */
911
912 /* b is pro-rated share of effective_cache_size */
914
915 /* force it positive and integral */
917 b = 1.0;
918 else
920
921 /* This part is the Mackert and Lohman formula */
923 {
924 pages_fetched =
928 else
930 }
931 else
932 {
934
937 {
938 pages_fetched =
940 }
941 else
942 {
943 pages_fetched =
945 }
947 }
949}
References Assert, b, effective_cache_size, fb(), Max, root, and T.
Referenced by compute_bitmap_pages(), cost_index(), genericcostestimate(), and gincostestimate().
◆ initial_cost_hashjoin()
|
extern |
Definition at line 4301 of file costsize.c.
4307{
4308 int disabled_nodes;
4309 Cost startup_cost = 0;
4310 Cost run_cost = 0;
4315 int numbuckets;
4316 int numbatches;
4318 size_t space_allowed; /* unused */
4320
4323
4324 /* Count up disabled nodes. */
4326 disabled_nodes += inner_path->disabled_nodes;
4327 disabled_nodes += outer_path->disabled_nodes;
4328
4329 /* cost of source data */
4330 startup_cost += outer_path->startup_cost;
4332 startup_cost += inner_path->total_cost;
4333
4334 /*
4335 * Cost of computing hash function: must do it once per input tuple. We
4336 * charge one cpu_operator_cost for each column's hash function. Also,
4337 * tack on one cpu_tuple_cost per inner row, to model the costs of
4338 * inserting the row into the hashtable.
4339 *
4340 * XXX when a hashclause is more complex than a single operator, we really
4341 * should charge the extra eval costs of the left or right side, as
4342 * appropriate, here. This seems more work than it's worth at the moment.
4343 */
4345 * inner_path_rows;
4347
4348 /*
4349 * If this is a parallel hash build, then the value we have for
4350 * inner_rows_total currently refers only to the rows returned by each
4351 * participant. For shared hash table size estimation, we need the total
4352 * number, so we need to undo the division.
4353 */
4356
4357 /*
4358 * Get hash table size that executor would use for inner relation.
4359 *
4360 * XXX for the moment, always assume that skew optimization will be
4361 * performed. As long as SKEW_HASH_MEM_PERCENT is small, it's not worth
4362 * trying to determine that for sure.
4363 *
4364 * XXX at some point it might be interesting to try to account for skew
4365 * optimization in the cost estimate, but for now, we don't.
4366 */
4368 inner_path->pathtarget->width,
4369 true, /* useskew */
4371 outer_path->parallel_workers,
4372 &space_allowed,
4373 &numbuckets,
4374 &numbatches,
4375 &num_skew_mcvs);
4376
4377 /*
4378 * If inner relation is too big then we will need to "batch" the join,
4379 * which implies writing and reading most of the tuples to disk an extra
4380 * time. Charge seq_page_cost per page, since the I/O should be nice and
4381 * sequential. Writing the inner rel counts as startup cost, all the rest
4382 * as run cost.
4383 */
4384 if (numbatches > 1)
4385 {
4387 outer_path->pathtarget->width);
4389 inner_path->pathtarget->width);
4390
4393 }
4394
4395 /* CPU costs left for later */
4396
4397 /* Public result fields */
4398 workspace->disabled_nodes = disabled_nodes;
4399 workspace->startup_cost = startup_cost;
4400 workspace->total_cost = startup_cost + run_cost;
4401 /* Save private data for final_cost_hashjoin */
4402 workspace->run_cost = run_cost;
4403 workspace->numbuckets = numbuckets;
4404 workspace->numbatches = numbatches;
4406}
void ExecChooseHashTableSize(double ntuples, int tupwidth, bool useskew, bool try_combined_hash_mem, int parallel_workers, size_t *space_allowed, int *numbuckets, int *numbatches, int *num_skew_mcvs)
Definition nodeHash.c:657
References cpu_operator_cost, cpu_tuple_cost, JoinCostWorkspace::disabled_nodes, ExecChooseHashTableSize(), fb(), get_parallel_divisor(), JoinCostWorkspace::inner_rows_total, list_length(), JoinCostWorkspace::numbatches, JoinCostWorkspace::numbuckets, page_size(), PGS_CONSIDER_NONPARTIAL, PGS_HASHJOIN, JoinPathExtraData::pgs_mask, JoinCostWorkspace::run_cost, seq_page_cost, JoinCostWorkspace::startup_cost, and JoinCostWorkspace::total_cost.
Referenced by try_hashjoin_path(), and try_partial_hashjoin_path().
◆ initial_cost_mergejoin()
|
extern |
Definition at line 3662 of file costsize.c.
3669{
3670 int disabled_nodes;
3671 Cost startup_cost = 0;
3672 Cost run_cost = 0;
3675 Cost inner_run_cost;
3676 double outer_rows,
3677 inner_rows,
3678 outer_skip_rows,
3679 inner_skip_rows;
3681 outerendsel,
3682 innerstartsel,
3683 innerendsel;
3685 * cost_sort/cost_incremental_sort */
3686
3687 /* Protect some assumptions below that rowcounts aren't zero */
3689 outer_path_rows = 1;
3691 inner_path_rows = 1;
3692
3693 /*
3694 * A merge join will stop as soon as it exhausts either input stream
3695 * (unless it's an outer join, in which case the outer side has to be
3696 * scanned all the way anyway). Estimate fraction of the left and right
3697 * inputs that will actually need to be scanned. Likewise, we can
3698 * estimate the number of rows that will be skipped before the first join
3699 * pair is found, which should be factored into startup cost. We use only
3700 * the first (most significant) merge clause for this purpose. Since
3701 * mergejoinscansel() is a fairly expensive computation, we cache the
3702 * results in the merge clause RestrictInfo.
3703 */
3705 {
3711 MergeScanSelCache *cache;
3712
3713 /* Get the input pathkeys to determine the sort-order details */
3720 /* debugging check */
3726
3727 /* Get the selectivity with caching */
3729
3731 outer_path->parent->relids))
3732 {
3733 /* left side of clause is outer */
3738 }
3739 else
3740 {
3741 /* left side of clause is inner */
3746 }
3748 jointype == JOIN_ANTI)
3749 {
3750 outerstartsel = 0.0;
3751 outerendsel = 1.0;
3752 }
3754 jointype == JOIN_RIGHT_ANTI)
3755 {
3756 innerstartsel = 0.0;
3757 innerendsel = 1.0;
3758 }
3759 }
3760 else
3761 {
3762 /* cope with clauseless or full mergejoin */
3765 }
3766
3767 /*
3768 * Convert selectivities to row counts. We force outer_rows and
3769 * inner_rows to be at least 1, but the skip_rows estimates can be zero.
3770 */
3775
3776 Assert(outer_skip_rows <= outer_rows);
3777 Assert(inner_skip_rows <= inner_rows);
3778
3779 /*
3780 * Readjust scan selectivities to account for above rounding. This is
3781 * normally an insignificant effect, but when there are only a few rows in
3782 * the inputs, failing to do this makes for a large percentage error.
3783 */
3788
3791
3792 /*
3793 * We don't decide whether to materialize the inner path until we get to
3794 * final_cost_mergejoin(), so we don't know whether to check the pgs_mask
3795 * against PGS_MERGEJOIN_PLAIN or PGS_MERGEJOIN_MATERIALIZE. Instead, we
3796 * just account for any child nodes here and assume that this node is not
3797 * itself disabled; we can sort out the details in final_cost_mergejoin().
3798 *
3799 * (We could be more precise here by setting disabled_nodes to 1 at this
3800 * stage if both PGS_MERGEJOIN_PLAIN and PGS_MERGEJOIN_MATERIALIZE are
3801 * disabled, but that seems to against the idea of making this function
3802 * produce a quick, optimistic approximation of the final cost.)
3803 */
3804 disabled_nodes = 0;
3805
3806 /* cost of source data */
3807
3808 if (outersortkeys) /* do we need to sort outer? */
3809 {
3810 /*
3811 * We can assert that the outer path is not already ordered
3812 * appropriately for the mergejoin; otherwise, outersortkeys would
3813 * have been set to NIL.
3814 */
3816
3817 /*
3818 * We choose to use incremental sort if it is enabled and there are
3819 * presorted keys; otherwise we use full sort.
3820 */
3822 {
3824 root,
3825 outersortkeys,
3826 outer_presorted_keys,
3827 outer_path->disabled_nodes,
3828 outer_path->startup_cost,
3829 outer_path->total_cost,
3830 outer_path_rows,
3831 outer_path->pathtarget->width,
3832 0.0,
3833 work_mem,
3834 -1.0);
3835 }
3836 else
3837 {
3839 root,
3840 outersortkeys,
3841 outer_path->disabled_nodes,
3842 outer_path->total_cost,
3843 outer_path_rows,
3844 outer_path->pathtarget->width,
3845 0.0,
3846 work_mem,
3847 -1.0);
3848 }
3849
3850 disabled_nodes += sort_path.disabled_nodes;
3851 startup_cost += sort_path.startup_cost;
3853 * outerstartsel;
3856 }
3857 else
3858 {
3859 disabled_nodes += outer_path->disabled_nodes;
3860 startup_cost += outer_path->startup_cost;
3862 * outerstartsel;
3865 }
3866
3867 if (innersortkeys) /* do we need to sort inner? */
3868 {
3869 /*
3870 * We can assert that the inner path is not already ordered
3871 * appropriately for the mergejoin; otherwise, innersortkeys would
3872 * have been set to NIL.
3873 */
3875
3876 /*
3877 * We do not consider incremental sort for inner path, because
3878 * incremental sort does not support mark/restore.
3879 */
3880
3882 root,
3883 innersortkeys,
3884 inner_path->disabled_nodes,
3885 inner_path->total_cost,
3886 inner_path_rows,
3887 inner_path->pathtarget->width,
3888 0.0,
3889 work_mem,
3890 -1.0);
3891 disabled_nodes += sort_path.disabled_nodes;
3892 startup_cost += sort_path.startup_cost;
3894 * innerstartsel;
3897 }
3898 else
3899 {
3900 disabled_nodes += inner_path->disabled_nodes;
3901 startup_cost += inner_path->startup_cost;
3903 * innerstartsel;
3906 }
3907
3908 /*
3909 * We can't yet determine whether rescanning occurs, or whether
3910 * materialization of the inner input should be done. The minimum
3911 * possible inner input cost, regardless of rescan and materialization
3912 * considerations, is inner_run_cost. We include that in
3913 * workspace->total_cost, but not yet in run_cost.
3914 */
3915
3916 /* CPU costs left for later */
3917
3918 /* Public result fields */
3919 workspace->disabled_nodes = disabled_nodes;
3920 workspace->startup_cost = startup_cost;
3921 workspace->total_cost = startup_cost + run_cost + inner_run_cost;
3922 /* Save private data for final_cost_mergejoin */
3923 workspace->run_cost = run_cost;
3924 workspace->inner_run_cost = inner_run_cost;
3925 workspace->outer_rows = outer_rows;
3926 workspace->inner_rows = inner_rows;
3927 workspace->outer_skip_rows = outer_skip_rows;
3928 workspace->inner_skip_rows = inner_skip_rows;
3929}
static MergeScanSelCache * cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey)
Definition costsize.c:4222
Definition pathnodes.h:3039
References Assert, bms_is_subset(), cached_scansel(), clamp_row_est(), cost_incremental_sort(), cost_sort(), JoinCostWorkspace::disabled_nodes, elog, enable_incremental_sort, ERROR, fb(), JoinCostWorkspace::inner_rows, JoinCostWorkspace::inner_run_cost, JoinCostWorkspace::inner_skip_rows, JOIN_ANTI, JOIN_FULL, JOIN_LEFT, JOIN_RIGHT, JOIN_RIGHT_ANTI, MergeScanSelCache::leftendsel, MergeScanSelCache::leftstartsel, linitial, JoinCostWorkspace::outer_rows, JoinCostWorkspace::outer_skip_rows, pathkeys_contained_in(), MergeScanSelCache::rightendsel, MergeScanSelCache::rightstartsel, root, JoinCostWorkspace::run_cost, JoinCostWorkspace::startup_cost, JoinCostWorkspace::total_cost, and work_mem.
Referenced by try_mergejoin_path(), and try_partial_mergejoin_path().
◆ initial_cost_nestloop()
|
extern |
Definition at line 3377 of file costsize.c.
3381{
3382 int disabled_nodes;
3383 Cost startup_cost = 0;
3384 Cost run_cost = 0;
3388 Cost inner_run_cost;
3389 Cost inner_rescan_run_cost;
3390
3391 /* Count up disabled nodes. */
3393 disabled_nodes += inner_path->disabled_nodes;
3394 disabled_nodes += outer_path->disabled_nodes;
3395
3396 /* estimate costs to rescan the inner relation */
3398 &inner_rescan_start_cost,
3399 &inner_rescan_total_cost);
3400
3401 /* cost of source data */
3402
3403 /*
3404 * NOTE: clearly, we must pay both outer and inner paths' startup_cost
3405 * before we can start returning tuples, so the join's startup cost is
3406 * their sum. We'll also pay the inner path's rescan startup cost
3407 * multiple times.
3408 */
3413
3416
3418 extra->inner_unique)
3419 {
3420 /*
3421 * With a SEMI or ANTI join, or if the innerrel is known unique, the
3422 * executor will stop after the first match.
3423 *
3424 * Getting decent estimates requires inspection of the join quals,
3425 * which we choose to postpone to final_cost_nestloop.
3426 */
3427
3428 /* Save private data for final_cost_nestloop */
3429 workspace->inner_run_cost = inner_run_cost;
3430 workspace->inner_rescan_run_cost = inner_rescan_run_cost;
3431 }
3432 else
3433 {
3434 /* Normal case; we'll scan whole input rel for each outer row */
3435 run_cost += inner_run_cost;
3437 run_cost += (outer_path_rows - 1) * inner_rescan_run_cost;
3438 }
3439
3440 /* CPU costs left for later */
3441
3442 /* Public result fields */
3443 workspace->disabled_nodes = disabled_nodes;
3444 workspace->startup_cost = startup_cost;
3445 workspace->total_cost = startup_cost + run_cost;
3446 /* Save private data for final_cost_nestloop */
3447 workspace->run_cost = run_cost;
3448}
static void cost_rescan(PlannerInfo *root, Path *path, Cost *rescan_startup_cost, Cost *rescan_total_cost)
Definition costsize.c:4788
References cost_rescan(), JoinCostWorkspace::disabled_nodes, fb(), JoinCostWorkspace::inner_rescan_run_cost, JoinCostWorkspace::inner_run_cost, JoinPathExtraData::inner_unique, JOIN_ANTI, JOIN_SEMI, JoinPathExtraData::pgs_mask, root, JoinCostWorkspace::run_cost, JoinCostWorkspace::startup_cost, and JoinCostWorkspace::total_cost.
Referenced by try_nestloop_path(), and try_partial_nestloop_path().
◆ set_baserel_size_estimates()
|
extern |
Definition at line 5496 of file costsize.c.
5497{
5498 double nrows;
5499
5500 /* Should only be applied to base relations */
5502
5503 nrows = rel->tuples *
5505 rel->baserestrictinfo,
5506 0,
5507 JOIN_INNER,
5508 NULL);
5509
5511
5513
5515}
static void set_rel_width(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6357
References Assert, RelOptInfo::baserestrictcost, RelOptInfo::baserestrictinfo, clamp_row_est(), clauselist_selectivity(), cost_qual_eval(), fb(), 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()
|
extern |
Definition at line 6222 of file costsize.c.
6223{
6225
6226 /* Should only be applied to base relations that are CTE references */
6230
6232 {
6233 /*
6234 * In a self-reference, we assume the average worktable size is a
6235 * multiple of the nonrecursive term's size. The best multiplier will
6236 * vary depending on query "fan-out", so make its value adjustable.
6237 */
6239 }
6240 else
6241 {
6242 /* Otherwise just believe the CTE's rowcount estimate */
6244 }
6245
6246 /* Now estimate number of output rows, etc */
6248}
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:5496
References Assert, clamp_row_est(), fb(), planner_rt_fetch, recursive_worktable_factor, RelOptInfo::relid, root, RTE_CTE, set_baserel_size_estimates(), and RelOptInfo::tuples.
Referenced by set_cte_pathlist(), and set_worktable_pathlist().
◆ set_foreign_size_estimates()
|
extern |
Definition at line 6322 of file costsize.c.
6323{
6324 /* Should only be applied to base relations */
6326
6328
6330
6332}
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()
|
extern |
Definition at line 6130 of file costsize.c.
6131{
6134
6135 /* Should only be applied to base relations that are functions */
6139
6140 /*
6141 * Estimate number of rows the functions will return. The rowcount of the
6142 * node is that of the largest function result.
6143 */
6144 rel->tuples = 0;
6146 {
6149
6152 }
6153
6154 /* Now estimate number of output rows, etc */
6156}
double expression_returns_set_rows(PlannerInfo *root, Node *clause)
Definition clauses.c:298
Definition parsenodes.h:1375
References Assert, expression_returns_set_rows(), fb(), RangeTblFunction::funcexpr, lfirst, planner_rt_fetch, RelOptInfo::relid, root, RTE_FUNCTION, set_baserel_size_estimates(), and RelOptInfo::tuples.
Referenced by set_rel_size().
◆ set_joinrel_size_estimates()
|
extern |
Definition at line 5575 of file costsize.c.
5580{
5582 rel,
5583 outer_rel,
5584 inner_rel,
5585 outer_rel->rows,
5586 inner_rel->rows,
5587 sjinfo,
5588 restrictlist);
5589}
References calc_joinrel_size_estimate(), fb(), root, and RelOptInfo::rows.
Referenced by build_child_join_rel(), build_join_rel(), and make_grouped_join_rel().
◆ set_namedtuplestore_size_estimates()
|
extern |
Definition at line 6260 of file costsize.c.
6261{
6263
6264 /* Should only be applied to base relations that are tuplestore references */
6268
6269 /*
6270 * Use the estimate provided by the code which is generating the named
6271 * tuplestore. In some cases, the actual number might be available; in
6272 * others the same plan will be re-used, so a "typical" value might be
6273 * estimated and used.
6274 */
6277 rel->tuples = 1000;
6278
6279 /* Now estimate number of output rows, etc */
6281}
References Assert, fb(), planner_rt_fetch, RelOptInfo::relid, root, RTE_NAMEDTUPLESTORE, set_baserel_size_estimates(), and RelOptInfo::tuples.
Referenced by set_namedtuplestore_pathlist().
◆ set_pathtarget_cost_width()
|
extern |
Definition at line 6514 of file costsize.c.
6515{
6518
6519 /* Vars are assumed to have cost zero, but other exprs do not */
6522
6524 {
6526
6528
6529 /* For non-Vars, account for evaluation cost */
6531 {
6532 QualCost cost;
6533
6537 }
6538 }
6539
6541
6542 return target;
6543}
static int32 get_expr_width(PlannerInfo *root, const Node *expr)
Definition costsize.c:6552
Definition primnodes.h:262
References clamp_width_est(), PathTarget::cost, cost_qual_eval_node(), PathTarget::exprs, fb(), get_expr_width(), IsA, lfirst, QualCost::per_tuple, root, QualCost::startup, and PathTarget::width.
Referenced by create_rel_agg_info(), make_group_input_target(), make_partial_grouping_target(), make_sort_input_target(), make_window_input_target(), and split_pathtarget_at_srfs_extended().
◆ set_result_size_estimates()
|
extern |
Definition at line 6293 of file costsize.c.
6294{
6295 /* Should only be applied to RTE_RESULT base relations */
6298
6299 /* RTE_RESULT always generates a single row, natively */
6300 rel->tuples = 1;
6301
6302 /* Now estimate number of output rows, etc */
6304}
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()
|
extern |
Definition at line 6050 of file costsize.c.
6051{
6055
6056 /* Should only be applied to base relations that are subqueries */
6059
6060 /*
6061 * Copy raw number of output rows from subquery. All of its paths should
6062 * have the same output rowcount, so just look at cheapest-total.
6063 */
6066
6067 /*
6068 * Compute per-output-column width estimates by examining the subquery's
6069 * targetlist. For any output that is a plain Var, get the width estimate
6070 * that was made while planning the subquery. Otherwise, we leave it to
6071 * set_rel_width to fill in a datatype-based default estimate.
6072 */
6074 {
6078
6079 /* junk columns aren't visible to upper query */
6080 if (te->resjunk)
6081 continue;
6082
6083 /*
6084 * The subquery could be an expansion of a view that's had columns
6085 * added to it since the current query was parsed, so that there are
6086 * non-junk tlist columns in it that don't correspond to any column
6087 * visible at our query level. Ignore such columns.
6088 */
6090 continue;
6091
6092 /*
6093 * XXX This currently doesn't work for subqueries containing set
6094 * operations, because the Vars in their tlists are bogus references
6095 * to the first leaf subquery, which wouldn't give the right answer
6096 * even if we could still get to its PlannerInfo.
6097 *
6098 * Also, the subquery could be an appendrel for which all branches are
6099 * known empty due to constraint exclusion, in which case
6100 * set_append_rel_pathlist will have left the attr_widths set to zero.
6101 *
6102 * In either case, we just leave the width estimate zero until
6103 * set_rel_width fixes it.
6104 */
6107 {
6110
6112 }
6114 }
6115
6116 /* Now estimate number of output rows, etc */
6118}
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition relnode.c:1606
Definition pathnodes.h:297
Definition primnodes.h:2236
References Assert, TargetEntry::expr, fb(), fetch_upper_rel(), find_base_rel(), IsA, lfirst_node, RelOptInfo::max_attr, RelOptInfo::min_attr, PlannerInfo::parse, planner_rt_fetch, RelOptInfo::relid, TargetEntry::resno, root, 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()
|
extern |
Definition at line 6168 of file costsize.c.
6169{
6170 /* Should only be applied to base relations that are functions */
6173
6174 rel->tuples = 100;
6175
6176 /* Now estimate number of output rows, etc */
6178}
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()
|
extern |
Definition at line 6190 of file costsize.c.
6191{
6193
6194 /* Should only be applied to base relations that are values lists */
6198
6199 /*
6200 * Estimate number of rows the values list will return. We know this
6201 * precisely based on the list length (well, barring set-returning
6202 * functions in list items, but that's a refinement not catered for
6203 * anywhere else either).
6204 */
6206
6207 /* Now estimate number of output rows, etc */
6209}
References Assert, fb(), list_length(), planner_rt_fetch, RelOptInfo::relid, root, RTE_VALUES, set_baserel_size_estimates(), and RelOptInfo::tuples.
Referenced by set_rel_size().
Variable Documentation
◆ constraint_exclusion
|
extern |
Definition at line 58 of file plancat.c.
Referenced by relation_excluded_by_constraints().
◆ disable_cost
|
extern |
Definition at line 141 of file costsize.c.
Referenced by final_cost_hashjoin().
◆ enable_async_append
|
extern |
Definition at line 165 of file costsize.c.
Referenced by create_append_plan().
◆ enable_bitmapscan
|
extern |
Definition at line 148 of file costsize.c.
Referenced by standard_planner().
◆ enable_gathermerge
|
extern |
Definition at line 158 of file costsize.c.
Referenced by standard_planner().
◆ enable_hashagg
|
extern |
Definition at line 152 of file costsize.c.
Referenced by compute_semijoin_info(), cost_agg(), create_final_distinct_paths(), create_partial_distinct_paths(), and create_setop_path().
◆ enable_hashjoin
|
extern |
Definition at line 157 of file costsize.c.
Referenced by standard_planner().
◆ enable_incremental_sort
|
extern |
Definition at line 151 of file costsize.c.
Referenced by build_setop_child_paths(), cost_append(), cost_incremental_sort(), create_append_plan(), create_final_unique_paths(), create_merge_append_path(), create_merge_append_plan(), create_mergejoin_plan(), create_one_window_path(), create_ordered_paths(), create_partial_unique_paths(), gather_grouping_paths(), generate_grouped_paths(), generate_useful_gather_paths(), get_useful_group_keys_orderings(), get_useful_pathkeys_for_distinct(), initial_cost_mergejoin(), and make_ordered_path().
◆ enable_indexonlyscan
|
extern |
Definition at line 147 of file costsize.c.
Referenced by standard_planner().
◆ enable_indexscan
|
extern |
Definition at line 146 of file costsize.c.
Referenced by plan_cluster_use_sort(), and standard_planner().
◆ enable_material
|
extern |
Definition at line 154 of file costsize.c.
Referenced by build_subplan(), materialize_finished_plan(), and standard_planner().
◆ enable_memoize
|
extern |
Definition at line 155 of file costsize.c.
Referenced by standard_planner().
◆ enable_mergejoin
|
extern |
Definition at line 156 of file costsize.c.
Referenced by standard_planner().
◆ enable_nestloop
|
extern |
Definition at line 153 of file costsize.c.
Referenced by standard_planner().
◆ enable_parallel_append
|
extern |
Definition at line 161 of file costsize.c.
Referenced by add_paths_to_append_rel(), and generate_union_paths().
◆ enable_parallel_hash
|
extern |
Definition at line 162 of file costsize.c.
Referenced by hash_inner_and_outer().
◆ enable_partition_pruning
|
extern |
Definition at line 163 of file costsize.c.
Referenced by create_append_plan(), create_merge_append_plan(), and prune_append_rel_partitions().
◆ enable_partitionwise_aggregate
|
extern |
Definition at line 160 of file costsize.c.
Referenced by create_grouping_paths().
◆ enable_partitionwise_join
|
extern |
Definition at line 159 of file costsize.c.
Referenced by set_append_rel_size(), and standard_planner().
◆ enable_presorted_aggregate
|
extern |
Definition at line 164 of file costsize.c.
Referenced by adjust_group_pathkeys_for_groupagg().
◆ enable_seqscan
|
extern |
Definition at line 145 of file costsize.c.
Referenced by standard_planner().
◆ enable_sort
|
extern |
Definition at line 150 of file costsize.c.
Referenced by cost_sort(), and make_sort().
◆ enable_tidscan
|
extern |
Definition at line 149 of file costsize.c.
Referenced by standard_planner().
◆ max_parallel_workers_per_gather
|
extern |
Definition at line 143 of file costsize.c.
Referenced by add_paths_to_append_rel(), cost_index(), create_partial_bitmap_paths(), create_plain_partial_paths(), create_tidscan_paths(), generate_union_paths(), and standard_planner().
