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 6657 of file costsize.c.
6660{
6661 Cost indexTotalCost;
6662 Selectivity indexSelectivity;
6665 double tuples_fetched;
6667 double maxentries;
6668
6669 /*
6670 * Fetch total cost of obtaining the bitmap, as well as its total
6671 * selectivity.
6672 */
6673 cost_bitmap_tree_node(bitmapqual, &indexTotalCost, &indexSelectivity);
6674
6675 /*
6676 * Estimate number of main-table pages fetched.
6677 */
6679
6681
6682 /*
6683 * For a single scan, the number of heap pages that need to be fetched is
6684 * the same as the Mackert and Lohman formula for the case T <= b (ie, no
6685 * re-reads needed).
6686 */
6688
6689 /*
6690 * Calculate the number of pages fetched from the heap. Then based on
6691 * current work_mem estimate get the estimated maxentries in the bitmap.
6692 * (Note that we always do this calculation based on the number of pages
6693 * that would be fetched in a single iteration, even if loop_count > 1.
6694 * That's correct, because only that number of entries will be stored in
6695 * the bitmap at one time.)
6696 */
6699
6701 {
6702 /*
6703 * For repeated bitmap scans, scale up the number of tuples fetched in
6704 * the Mackert and Lohman formula by the number of scans, so that we
6705 * estimate the number of pages fetched by all the scans. Then
6706 * pro-rate for one scan.
6707 */
6709 baserel->pages,
6710 get_indexpath_pages(bitmapqual),
6711 root);
6713 }
6714
6717 else
6719
6721 {
6722 double exact_pages;
6723 double lossy_pages;
6724
6725 /*
6726 * Crude approximation of the number of lossy pages. Because of the
6727 * way tbm_lossify() is coded, the number of lossy pages increases
6728 * very sharply as soon as we run short of memory; this formula has
6729 * that property and seems to perform adequately in testing, but it's
6730 * possible we could do better somehow.
6731 */
6733 exact_pages = heap_pages - lossy_pages;
6734
6735 /*
6736 * If there are lossy pages then recompute the number of tuples
6737 * processed by the bitmap heap node. We assume here that the chance
6738 * of a given tuple coming from an exact page is the same as the
6739 * chance that a given page is exact. This might not be true, but
6740 * it's not clear how we can do any better.
6741 */
6742 if (lossy_pages > 0)
6743 tuples_fetched =
6744 clamp_row_est(indexSelectivity *
6747 }
6748
6750 *cost_p = indexTotalCost;
6752 *tuples_p = tuples_fetched;
6753
6755}
double index_pages_fetched(double tuples_fetched, BlockNumber pages, double index_pages, PlannerInfo *root)
Definition costsize.c:897
void cost_bitmap_tree_node(Path *path, Cost *cost, Selectivity *selec)
Definition costsize.c:1115
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 6768 of file costsize.c.
6769{
6771
6773}
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 5257 of file costsize.c.
5265{
5271 ListCell *l;
5272
5273 /*
5274 * In an ANTI join, we must ignore clauses that are "pushed down", since
5275 * those won't affect the match logic. In a SEMI join, we do not
5276 * distinguish joinquals from "pushed down" quals, so just use the whole
5277 * restrictinfo list. For other outer join types, we should consider only
5278 * non-pushed-down quals, so that this devolves to an IS_OUTER_JOIN check.
5279 */
5281 {
5283 foreach(l, restrictlist)
5284 {
5286
5289 }
5290 }
5291 else
5292 joinquals = restrictlist;
5293
5294 /*
5295 * Get the JOIN_SEMI or JOIN_ANTI selectivity of the join clauses.
5296 */
5298 joinquals,
5299 0,
5301 sjinfo);
5302
5303 /*
5304 * Also get the normal inner-join selectivity of the join clauses.
5305 */
5307
5309 joinquals,
5310 0,
5311 JOIN_INNER,
5312 &norm_sjinfo);
5313
5314 /* Avoid leaking a lot of ListCells */
5317
5318 /*
5319 * jselec can be interpreted as the fraction of outer-rel rows that have
5320 * any matches (this is true for both SEMI and ANTI cases). And nselec is
5321 * the fraction of the Cartesian product that matches. So, the average
5322 * number of matches for each outer-rel row that has at least one match is
5323 * nselec * inner_rows / jselec.
5324 *
5325 * Note: it is correct to use the inner rel's "rows" count here, even
5326 * though we might later be considering a parameterized inner path with
5327 * fewer rows. This is because we have included all the join clauses in
5328 * the selectivity estimate.
5329 */
5331 {
5333 /* Clamp to sane range */
5335 }
5336 else
5337 avgmatch = 1.0;
5338
5341}
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:2882
Definition pathnodes.h:3209
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 2788 of file costsize.c.
2795{
2797 Cost startup_cost;
2798 Cost total_cost;
2800
2801 /* Use all-zero per-aggregate costs if NULL is passed */
2803 {
2806 }
2807
2808 /*
2809 * The transCost.per_tuple component of aggcosts should be charged once
2810 * per input tuple, corresponding to the costs of evaluating the aggregate
2811 * transfns and their input expressions. The finalCost.per_tuple component
2812 * is charged once per output tuple, corresponding to the costs of
2813 * evaluating the finalfns. Startup costs are of course charged but once.
2814 *
2815 * If we are grouping, we charge an additional cpu_operator_cost per
2816 * grouping column per input tuple for grouping comparisons.
2817 *
2818 * We will produce a single output tuple if not grouping, and a tuple per
2819 * group otherwise. We charge cpu_tuple_cost for each output tuple.
2820 *
2821 * Note: in this cost model, AGG_SORTED and AGG_HASHED have exactly the
2822 * same total CPU cost, but AGG_SORTED has lower startup cost. If the
2823 * input path is already sorted appropriately, AGG_SORTED should be
2824 * preferred (since it has no risk of memory overflow). This will happen
2825 * as long as the computed total costs are indeed exactly equal --- but if
2826 * there's roundoff error we might do the wrong thing. So be sure that
2827 * the computations below form the same intermediate values in the same
2828 * order.
2829 */
2831 {
2832 startup_cost = input_total_cost;
2833 startup_cost += aggcosts->transCost.startup;
2834 startup_cost += aggcosts->transCost.per_tuple * input_tuples;
2835 startup_cost += aggcosts->finalCost.startup;
2836 startup_cost += aggcosts->finalCost.per_tuple;
2837 /* we aren't grouping */
2838 total_cost = startup_cost + cpu_tuple_cost;
2839 output_tuples = 1;
2840 }
2842 {
2843 /* Here we are able to deliver output on-the-fly */
2844 startup_cost = input_startup_cost;
2845 total_cost = input_total_cost;
2847 ++disabled_nodes;
2848 /* calcs phrased this way to match HASHED case, see note above */
2849 total_cost += aggcosts->transCost.startup;
2850 total_cost += aggcosts->transCost.per_tuple * input_tuples;
2852 total_cost += aggcosts->finalCost.startup;
2853 total_cost += aggcosts->finalCost.per_tuple * numGroups;
2854 total_cost += cpu_tuple_cost * numGroups;
2855 output_tuples = numGroups;
2856 }
2857 else
2858 {
2859 /* must be AGG_HASHED */
2860 startup_cost = input_total_cost;
2862 ++disabled_nodes;
2863 startup_cost += aggcosts->transCost.startup;
2864 startup_cost += aggcosts->transCost.per_tuple * input_tuples;
2865 /* cost of computing hash value */
2867 startup_cost += aggcosts->finalCost.startup;
2868
2869 total_cost = startup_cost;
2870 total_cost += aggcosts->finalCost.per_tuple * numGroups;
2871 /* cost of retrieving from hash table */
2872 total_cost += cpu_tuple_cost * numGroups;
2873 output_tuples = numGroups;
2874 }
2875
2876 /*
2877 * Add the disk costs of hash aggregation that spills to disk.
2878 *
2879 * Groups that go into the hash table stay in memory until finalized, so
2880 * spilling and reprocessing tuples doesn't incur additional invocations
2881 * of transCost or finalCost. Furthermore, the computed hash value is
2882 * stored with the spilled tuples, so we don't incur extra invocations of
2883 * the hash function.
2884 *
2885 * Hash Agg begins returning tuples after the first batch is complete.
2886 * Accrue writes (spilled tuples) to startup_cost and to total_cost;
2887 * accrue reads only to total_cost.
2888 */
2890 {
2891 double pages;
2895 double hashentrysize;
2897 Size mem_limit;
2899 int num_partitions;
2900 int depth;
2901
2902 /*
2903 * Estimate number of batches based on the computed limits. If less
2904 * than or equal to one, all groups are expected to fit in memory;
2905 * otherwise we expect to spill.
2906 */
2908 input_width,
2909 aggcosts->transitionSpace);
2910 hash_agg_set_limits(hashentrysize, numGroups, 0, &mem_limit,
2911 &ngroups_limit, &num_partitions);
2912
2914 numGroups / ngroups_limit);
2915
2917 num_partitions = Max(num_partitions, 2);
2918
2919 /*
2920 * The number of partitions can change at different levels of
2921 * recursion; but for the purposes of this calculation assume it stays
2922 * constant.
2923 */
2925
2926 /*
2927 * Estimate number of pages read and written. For each level of
2928 * recursion, a tuple must be written and then later read.
2929 */
2932
2933 /*
2934 * HashAgg has somewhat worse IO behavior than Sort on typical
2935 * hardware/OS combinations. Account for this with a generic penalty.
2936 */
2937 pages_read *= 2.0;
2938 pages_written *= 2.0;
2939
2943
2944 /* account for CPU cost of spilling a tuple and reading it back */
2946 startup_cost += spill_cost;
2947 total_cost += spill_cost;
2948 }
2949
2950 /*
2951 * If there are quals (HAVING quals), account for their cost and
2952 * selectivity.
2953 */
2954 if (quals)
2955 {
2957
2959 startup_cost += qual_cost.startup;
2961
2964 quals,
2965 0,
2966 JOIN_INNER,
2967 NULL));
2968 }
2969
2971 path->disabled_nodes = disabled_nodes;
2972 path->startup_cost = startup_cost;
2973 path->total_cost = total_cost;
2974}
static double relation_byte_size(double tuples, int width)
Definition costsize.c:6596
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
Definition costsize.c:4899
Size hash_agg_entry_size(int numTrans, Size tupleWidth, Size transitionSpace)
Definition nodeAgg.c:1700
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:1808
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 2311 of file costsize.c.
2312{
2314 ListCell *l;
2316
2319
2320 apath->path.disabled_nodes =
2322 apath->path.startup_cost = 0;
2323 apath->path.total_cost = 0;
2324 apath->path.rows = 0;
2325
2327 return;
2328
2330 {
2332
2334 {
2336
2337 /*
2338 * For an unordered, non-parallel-aware Append we take the startup
2339 * cost as the startup cost of the first subpath.
2340 */
2342
2343 /*
2344 * Compute rows, number of disabled nodes, and total cost as sums
2345 * of underlying subplan values.
2346 */
2348 {
2350
2354 }
2355 }
2356 else
2357 {
2358 /*
2359 * For an ordered, non-parallel-aware Append we take the startup
2360 * cost as the sum of the subpath startup costs. This ensures
2361 * that we don't underestimate the startup cost when a query's
2362 * LIMIT is such that several of the children have to be run to
2363 * satisfy it. This might be overkill --- another plausible hack
2364 * would be to take the Append's startup cost as the maximum of
2365 * the child startup costs. But we don't want to risk believing
2366 * that an ORDER BY LIMIT query can be satisfied at small cost
2367 * when the first child has small startup cost but later ones
2368 * don't. (If we had the ability to deal with nonlinear cost
2369 * interpolation for partial retrievals, we would not need to be
2370 * so conservative about this.)
2371 *
2372 * This case is also different from the above in that we have to
2373 * account for possibly injecting sorts into subpaths that aren't
2374 * natively ordered.
2375 */
2377 {
2379 int presorted_keys;
2381 * cost_sort/cost_incremental_sort */
2382
2384 &presorted_keys))
2385 {
2386 /*
2387 * We'll need to insert a Sort node, so include costs for
2388 * that. We choose to use incremental sort if it is
2389 * enabled and there are presorted keys; otherwise we use
2390 * full sort.
2391 *
2392 * We can use the parent's LIMIT if any, since we
2393 * certainly won't pull more than that many tuples from
2394 * any child.
2395 */
2397 {
2399 root,
2400 pathkeys,
2401 presorted_keys,
2402 subpath->disabled_nodes,
2403 subpath->startup_cost,
2404 subpath->total_cost,
2405 subpath->rows,
2406 subpath->pathtarget->width,
2407 0.0,
2408 work_mem,
2409 apath->limit_tuples);
2410 }
2411 else
2412 {
2414 root,
2415 pathkeys,
2416 subpath->disabled_nodes,
2417 subpath->total_cost,
2418 subpath->rows,
2419 subpath->pathtarget->width,
2420 0.0,
2421 work_mem,
2422 apath->limit_tuples);
2423 }
2424
2426 }
2427
2432 }
2433 }
2434 }
2435 else /* parallel-aware */
2436 {
2439
2440 /* Parallel-aware Append never produces ordered output. */
2442
2443 /* Calculate startup cost. */
2445 {
2447
2448 /*
2449 * Append will start returning tuples when the child node having
2450 * lowest startup cost is done setting up. We consider only the
2451 * first few subplans that immediately get a worker assigned.
2452 */
2457 subpath->startup_cost);
2458
2459 /*
2460 * Apply parallel divisor to subpaths. Scale the number of rows
2461 * for each partial subpath based on the ratio of the parallel
2462 * divisor originally used for the subpath to the one we adopted.
2463 * Also add the cost of partial paths to the total cost, but
2464 * ignore non-partial paths for now.
2465 */
2468 else
2469 {
2471
2474 parallel_divisor);
2476 }
2477
2480
2481 i++;
2482 }
2483
2484 /* Add cost for non-partial subpaths. */
2485 apath->path.total_cost +=
2487 apath->first_partial_path,
2488 apath->path.parallel_workers);
2489 }
2490
2491 /*
2492 * Although Append does not do any selection or projection, it's not free;
2493 * add a small per-tuple overhead.
2494 */
2495 apath->path.total_cost +=
2497}
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:2201
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:2053
static Cost append_nonpartial_cost(List *subpaths, int numpaths, int parallel_workers)
Definition costsize.c:2235
bool pathkeys_count_contained_in(List *keys1, List *keys2, int *n_common)
Definition pathkeys.c:558
Definition pathnodes.h:1953
Definition pathnodes.h:998
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 1158 of file costsize.c.
1159{
1162 ListCell *l;
1163
1164 /*
1165 * We estimate AND selectivity on the assumption that the inputs are
1166 * independent. This is probably often wrong, but we don't have the info
1167 * to do better.
1168 *
1169 * The runtime cost of the BitmapAnd itself is estimated at 100x
1170 * cpu_operator_cost for each tbm_intersect needed. Probably too small,
1171 * definitely too simplistic?
1172 */
1173 totalCost = 0.0;
1174 selec = 1.0;
1176 {
1180
1182
1184
1188 }
1194}
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 1012 of file costsize.c.
1015{
1016 Cost startup_cost = 0;
1017 Cost run_cost = 0;
1018 Cost indexTotalCost;
1023 double tuples_fetched;
1026 spc_random_page_cost;
1029
1030 /* Should only be applied to base relations */
1034
1035 /* Mark the path with the correct row estimate */
1038 else
1040
1042 loop_count, &indexTotalCost,
1043 &tuples_fetched);
1044
1045 startup_cost += indexTotalCost;
1047
1048 /* Fetch estimated page costs for tablespace containing table. */
1050 &spc_random_page_cost,
1051 &spc_seq_page_cost);
1052
1053 /*
1054 * For small numbers of pages we should charge spc_random_page_cost
1055 * apiece, while if nearly all the table's pages are being read, it's more
1056 * appropriate to charge spc_seq_page_cost apiece. The effect is
1057 * nonlinear, too. For lack of a better idea, interpolate like this to
1058 * determine the cost per page.
1059 */
1061 cost_per_page = spc_random_page_cost -
1062 (spc_random_page_cost - spc_seq_page_cost)
1064 else
1065 cost_per_page = spc_random_page_cost;
1066
1068
1069 /*
1070 * Estimate CPU costs per tuple.
1071 *
1072 * Often the indexquals don't need to be rechecked at each tuple ... but
1073 * not always, especially not if there are enough tuples involved that the
1074 * bitmaps become lossy. For the moment, just assume they will be
1075 * rechecked always. This means we charge the full freight for all the
1076 * scan clauses.
1077 */
1079
1080 startup_cost += qpqual_cost.startup;
1083
1084 /* Adjust costing for parallelism, if used. */
1086 {
1088
1089 /* The CPU cost is divided among all the workers. */
1091
1093 }
1094 else
1096
1097
1098 run_cost += cpu_run_cost;
1099
1100 /* tlist eval costs are paid per output row, not per tuple scanned */
1101 startup_cost += path->pathtarget->cost.startup;
1102 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1103
1104 path->disabled_nodes =
1106 path->startup_cost = startup_cost;
1107 path->total_cost = startup_cost + run_cost;
1108}
static void get_restriction_qual_cost(PlannerInfo *root, RelOptInfo *baserel, ParamPathInfo *param_info, QualCost *qpqual_cost)
Definition costsize.c:5215
double compute_bitmap_pages(PlannerInfo *root, RelOptInfo *baserel, Path *bitmapqual, double loop_count, Cost *cost_p, double *tuples_p)
Definition costsize.c:6657
void get_tablespace_page_costs(Oid spcid, double *spc_random_page_cost, double *spc_seq_page_cost)
Definition spccache.c:183
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 1203 of file costsize.c.
1204{
1207 ListCell *l;
1208
1209 /*
1210 * We estimate OR selectivity on the assumption that the inputs are
1211 * non-overlapping, since that's often the case in "x IN (list)" type
1212 * situations. Of course, we clamp to 1.0 at the end.
1213 *
1214 * The runtime cost of the BitmapOr itself is estimated at 100x
1215 * cpu_operator_cost for each tbm_union needed. Probably too small,
1216 * definitely too simplistic? We are aware that the tbm_unions are
1217 * optimized out when the inputs are BitmapIndexScans.
1218 */
1219 totalCost = 0.0;
1220 selec = 0.0;
1222 {
1226
1228
1230
1235 }
1240}
Definition pathnodes.h:2042
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 1115 of file costsize.c.
1116{
1118 {
1119 *cost = ((IndexPath *) path)->indextotalcost;
1121
1122 /*
1123 * Charge a small amount per retrieved tuple to reflect the costs of
1124 * manipulating the bitmap. This is mostly to make sure that a bitmap
1125 * scan doesn't look to be the same cost as an indexscan to retrieve a
1126 * single tuple.
1127 */
1129 }
1131 {
1132 *cost = path->total_cost;
1134 }
1136 {
1137 *cost = path->total_cost;
1139 }
1140 else
1141 {
1144 }
1145}
Definition pathnodes.h:2129
Definition pathnodes.h:2142
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 1745 of file costsize.c.
1747{
1748 Cost startup_cost = 0;
1749 Cost run_cost = 0;
1753
1754 /* Should only be applied to base relations that are CTEs */
1757
1758 /* Mark the path with the correct row estimate */
1761 else
1763
1764 /* Charge one CPU tuple cost per row for tuplestore manipulation */
1766
1767 /* Add scanning CPU costs */
1769
1770 startup_cost += qpqual_cost.startup;
1773
1774 /* tlist eval costs are paid per output row, not per tuple scanned */
1775 startup_cost += path->pathtarget->cost.startup;
1776 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1777
1780 path->disabled_nodes =
1782 path->startup_cost = startup_cost;
1783 path->total_cost = startup_cost + run_cost;
1784}
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 1563 of file costsize.c.
1565{
1566 Cost startup_cost = 0;
1567 Cost run_cost = 0;
1573
1574 /* Should only be applied to base relations that are functions */
1578
1579 /* Mark the path with the correct row estimate */
1582 else
1584
1585 /*
1586 * Estimate costs of executing the function expression(s).
1587 *
1588 * Currently, nodeFunctionscan.c always executes the functions to
1589 * completion before returning any rows, and caches the results in a
1590 * tuplestore. So the function eval cost is all startup cost, and per-row
1591 * costs are minimal.
1592 *
1593 * XXX in principle we ought to charge tuplestore spill costs if the
1594 * number of rows is large. However, given how phony our rowcount
1595 * estimates for functions tend to be, there's not a lot of point in that
1596 * refinement right now.
1597 */
1599
1601
1602 /* Add scanning CPU costs */
1604
1605 startup_cost += qpqual_cost.startup;
1608
1609 /* tlist eval costs are paid per output row, not per tuple scanned */
1610 startup_cost += path->pathtarget->cost.startup;
1611 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1612
1615 path->disabled_nodes =
1617 path->startup_cost = startup_cost;
1618 path->total_cost = startup_cost + run_cost;
1619}
void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root)
Definition costsize.c:4925
Definition nodes.h:135
Definition parsenodes.h:1135
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 430 of file costsize.c.
433{
434 Cost startup_cost = 0;
435 Cost run_cost = 0;
436
437 /* Mark the path with the correct row estimate */
438 if (rows)
442 else
444
446
448
449 /* Parallel setup and communication cost. */
450 startup_cost += parallel_setup_cost;
452
457}
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 470 of file costsize.c.
475{
476 Cost startup_cost = 0;
477 Cost run_cost = 0;
479 double N;
481
482 /* Mark the path with the correct row estimate */
483 if (rows)
487 else
489
490 /*
491 * Add one to the number of workers to account for the leader. This might
492 * be overgenerous since the leader will do less work than other workers
493 * in typical cases, but we'll go with it for now.
494 */
498
499 /* Assumed cost per tuple comparison */
501
502 /* Heap creation cost */
504
505 /* Per-tuple heap maintenance cost */
507
508 /* small cost for heap management, like cost_merge_append */
510
511 /*
512 * Parallel setup and communication cost. Since Gather Merge, unlike
513 * Gather, requires us to block until a tuple is available from every
514 * worker, we bump the IPC cost up a little bit as compared with Gather.
515 * For lack of a better idea, charge an extra 5%.
516 */
517 startup_cost += parallel_setup_cost;
519
524}
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 3301 of file costsize.c.
3307{
3309 Cost startup_cost;
3310 Cost total_cost;
3311
3312 output_tuples = numGroups;
3313 startup_cost = input_startup_cost;
3314 total_cost = input_total_cost;
3315
3316 /*
3317 * Charge one cpu_operator_cost per comparison per input tuple. We assume
3318 * all columns get compared at most of the tuples.
3319 */
3321
3322 /*
3323 * If there are quals (HAVING quals), account for their cost and
3324 * selectivity.
3325 */
3326 if (quals)
3327 {
3329
3331 startup_cost += qual_cost.startup;
3333
3336 quals,
3337 0,
3338 JOIN_INNER,
3339 NULL));
3340 }
3341
3344 path->startup_cost = startup_cost;
3345 path->total_cost = total_cost;
3346}
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 2053 of file costsize.c.
2059{
2060 Cost startup_cost,
2061 run_cost,
2064 input_groups;
2066 group_run_cost,
2067 group_input_run_cost;
2069 ListCell *l;
2071
2073
2074 /*
2075 * We want to be sure the cost of a sort is never estimated as zero, even
2076 * if passed-in tuple count is zero. Besides, mustn't do log(0)...
2077 */
2078 if (input_tuples < 2.0)
2079 input_tuples = 2.0;
2080
2081 /* Default estimate of number of groups, capped to one group per row. */
2083
2084 /*
2085 * Extract presorted keys as list of expressions.
2086 *
2087 * We need to be careful about Vars containing "varno 0" which might have
2088 * been introduced by generate_append_tlist, which would confuse
2089 * estimate_num_groups (in fact it'd fail for such expressions). See
2090 * recurse_set_operations which has to deal with the same issue.
2091 *
2092 * Unlike recurse_set_operations we can't access the original target list
2093 * here, and even if we could it's not very clear how useful would that be
2094 * for a set operation combining multiple tables. So we simply detect if
2095 * there are any expressions with "varno 0" and use the default
2096 * DEFAULT_NUM_DISTINCT in that case.
2097 *
2098 * We might also use either 1.0 (a single group) or input_tuples (each row
2099 * being a separate group), pretty much the worst and best case for
2100 * incremental sort. But those are extreme cases and using something in
2101 * between seems reasonable. Furthermore, generate_append_tlist is used
2102 * for set operations, which are likely to produce mostly unique output
2103 * anyway - from that standpoint the DEFAULT_NUM_DISTINCT is defensive
2104 * while maintaining lower startup cost.
2105 */
2106 foreach(l, pathkeys)
2107 {
2111
2112 /*
2113 * Check if the expression contains Var with "varno 0" so that we
2114 * don't call estimate_num_groups in that case.
2115 */
2117 {
2119 break;
2120 }
2121
2122 /* expression not containing any Vars with "varno 0" */
2124
2126 break;
2127 }
2128
2129 /* Estimate the number of groups with equal presorted keys. */
2133
2136
2137 /*
2138 * Estimate the average cost of sorting of one group where presorted keys
2139 * are equal.
2140 */
2143 limit_tuples);
2144
2145 /*
2146 * Startup cost of incremental sort is the startup cost of its first group
2147 * plus the cost of its input.
2148 */
2150 group_input_run_cost;
2151
2152 /*
2153 * After we started producing tuples from the first group, the cost of
2154 * producing all the tuples is given by the cost to finish processing this
2155 * group, plus the total cost to process the remaining groups, plus the
2156 * remaining cost of input.
2157 */
2160
2161 /*
2162 * Incremental sort adds some overhead by itself. Firstly, it has to
2163 * detect the sort groups. This is roughly equal to one extra copy and
2164 * comparison per tuple.
2165 */
2167
2168 /*
2169 * Additionally, we charge double cpu_tuple_cost for each input group to
2170 * account for the tuplesort_reset that's performed after each group.
2171 */
2173
2174 path->rows = input_tuples;
2175
2176 /*
2177 * We should not generate these paths when enable_incremental_sort=false.
2178 * We can ignore PGS_CONSIDER_NONPARTIAL here, because if it's relevant,
2179 * it will have already affected the input path.
2180 */
2183
2184 path->startup_cost = startup_cost;
2185 path->total_cost = startup_cost + run_cost;
2186}
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:1951
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3788
Definition pathnodes.h:1703
Definition pathnodes.h:1795
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 545 of file costsize.c.
547{
551 amcostestimate_function amcostestimate;
553 Cost startup_cost = 0;
554 Cost run_cost = 0;
556 Cost indexStartupCost;
557 Cost indexTotalCost;
558 Selectivity indexSelectivity;
559 double indexCorrelation,
560 csquared;
562 spc_random_page_cost;
564 max_IO_cost;
567 double tuples_fetched;
572
573 /* Should only be applied to base relations */
578
579 /*
580 * Mark the path with the correct row estimate, and identify which quals
581 * will need to be enforced as qpquals. We need not check any quals that
582 * are implied by the index's predicate, so we can use indrestrictinfo not
583 * baserestrictinfo as the list of relevant restriction clauses for the
584 * rel.
585 */
587 {
589 /* qpquals come from the rel's restriction clauses and ppi_clauses */
591 path->indexclauses),
593 path->indexclauses));
594 }
595 else
596 {
598 /* qpquals come from just the rel's restriction clauses */
600 path->indexclauses);
601 }
602
603 /* is this scan type disabled? */
608
609 /*
610 * Call index-access-method-specific code to estimate the processing cost
611 * for scanning the index, as well as the selectivity of the index (ie,
612 * the fraction of main-table tuples we will have to retrieve) and its
613 * correlation to the main-table tuple order. We need a cast here because
614 * pathnodes.h uses a weak function type to avoid including amapi.h.
615 */
618 &indexStartupCost, &indexTotalCost,
619 &indexSelectivity, &indexCorrelation,
620 &index_pages);
621
622 /*
623 * Save amcostestimate's results for possible use in bitmap scan planning.
624 * We don't bother to save indexStartupCost or indexCorrelation, because a
625 * bitmap scan doesn't care about either.
626 */
627 path->indextotalcost = indexTotalCost;
628 path->indexselectivity = indexSelectivity;
629
630 /* all costs for touching index itself included here */
631 startup_cost += indexStartupCost;
632 run_cost += indexTotalCost - indexStartupCost;
633
634 /* estimate number of main-table tuples fetched */
636
637 /* fetch estimated page costs for tablespace containing table */
639 &spc_random_page_cost,
640 &spc_seq_page_cost);
641
642 /*----------
643 * Estimate number of main-table pages fetched, and compute I/O cost.
644 *
645 * When the index ordering is uncorrelated with the table ordering,
646 * we use an approximation proposed by Mackert and Lohman (see
647 * index_pages_fetched() for details) to compute the number of pages
648 * fetched, and then charge spc_random_page_cost per page fetched.
649 *
650 * When the index ordering is exactly correlated with the table ordering
651 * (just after a CLUSTER, for example), the number of pages fetched should
652 * be exactly selectivity * table_size. What's more, all but the first
653 * will be sequential fetches, not the random fetches that occur in the
654 * uncorrelated case. So if the number of pages is more than 1, we
655 * ought to charge
656 * spc_random_page_cost + (pages_fetched - 1) * spc_seq_page_cost
657 * For partially-correlated indexes, we ought to charge somewhere between
658 * these two estimates. We currently interpolate linearly between the
659 * estimates based on the correlation squared (XXX is that appropriate?).
660 *
661 * If it's an index-only scan, then we will not need to fetch any heap
662 * pages for which the visibility map shows all tuples are visible.
663 * Hence, reduce the estimated number of heap fetches accordingly.
664 * We use the measured fraction of the entire heap that is all-visible,
665 * which might not be particularly relevant to the subset of the heap
666 * that this query will fetch; but it's not clear how to do better.
667 *----------
668 */
670 {
671 /*
672 * For repeated indexscans, the appropriate estimate for the
673 * uncorrelated case is to scale up the number of tuples fetched in
674 * the Mackert and Lohman formula by the number of scans, so that we
675 * estimate the number of pages fetched by all the scans; then
676 * pro-rate the costs for one scan. In this case we assume all the
677 * fetches are random accesses.
678 */
680 baserel->pages,
682 root);
683
686
688
690
691 /*
692 * In the perfectly correlated case, the number of pages touched by
693 * each scan is selectivity * table_size, and we can use the Mackert
694 * and Lohman formula at the page level to estimate how much work is
695 * saved by caching across scans. We still assume all the fetches are
696 * random, though, which is an overestimate that's hard to correct for
697 * without double-counting the cache effects. (But in most cases
698 * where such a plan is actually interesting, only one page would get
699 * fetched per scan anyway, so it shouldn't matter much.)
700 */
702
704 baserel->pages,
706 root);
707
710
712 }
713 else
714 {
715 /*
716 * Normal case: apply the Mackert and Lohman formula, and then
717 * interpolate between that and the correlation-derived result.
718 */
720 baserel->pages,
722 root);
723
726
728
729 /* max_IO_cost is for the perfectly uncorrelated case (csquared=0) */
731
732 /* min_IO_cost is for the perfectly correlated case (csquared=1) */
734
737
739 {
740 min_IO_cost = spc_random_page_cost;
743 }
744 else
745 min_IO_cost = 0;
746 }
747
749 {
750 /*
751 * For index only scans compute workers based on number of index pages
752 * fetched; the number of heap pages we fetch might be so small as to
753 * effectively rule out parallelism, which we don't want to do.
754 */
756 rand_heap_pages = -1;
757
758 /*
759 * Estimate the number of parallel workers required to scan index. Use
760 * the number of heap pages computed considering heap fetches won't be
761 * sequential as for parallel scans the pages are accessed in random
762 * order.
763 */
765 rand_heap_pages,
766 index_pages,
768
769 /*
770 * Fall out if workers can't be assigned for parallel scan, because in
771 * such a case this path will be rejected. So there is no benefit in
772 * doing extra computation.
773 */
775 return;
776
778 }
779
780 /*
781 * Now interpolate based on estimated index order correlation to get total
782 * disk I/O cost for main table accesses.
783 */
784 csquared = indexCorrelation * indexCorrelation;
785
787
788 /*
789 * Estimate CPU costs per tuple.
790 *
791 * What we want here is cpu_tuple_cost plus the evaluation costs of any
792 * qual clauses that we have to evaluate as qpquals.
793 */
795
796 startup_cost += qpqual_cost.startup;
798
800
801 /* tlist eval costs are paid per output row, not per tuple scanned */
802 startup_cost += path->path.pathtarget->cost.startup;
804
805 /* Adjust costing for parallelism, if used. */
807 {
809
811
812 /* The CPU cost is divided among all the workers. */
814 }
815
816 run_cost += cpu_run_cost;
817
820}
int compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages, int max_workers)
Definition allpaths.c:4794
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:839
Definition pathnodes.h:1335
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 2583 of file costsize.c.
2587{
2592
2593 path->rows = tuples;
2594
2595 /*
2596 * Whether spilling or not, charge 2x cpu_operator_cost per tuple to
2597 * reflect bookkeeping overhead. (This rate must be more than what
2598 * cost_rescan charges for materialize, ie, cpu_operator_cost per tuple;
2599 * if it is exactly the same then there will be a cost tie between
2600 * nestloop with A outer, materialized B inner and nestloop with B outer,
2601 * materialized A inner. The extra cost ensures we'll prefer
2602 * materializing the smaller rel.) Note that this is normally a good deal
2603 * less than cpu_tuple_cost; which is OK because a Material plan node
2604 * doesn't do qual-checking or projection, so it's got less overhead than
2605 * most plan nodes.
2606 */
2607 run_cost += 2 * cpu_operator_cost * tuples;
2608
2609 /*
2610 * If we will spill to disk, charge at the rate of seq_page_cost per page.
2611 * This cost is assumed to be evenly spread through the plan run phase,
2612 * which isn't exactly accurate but our cost model doesn't allow for
2613 * nonuniform costs within the run phase.
2614 */
2616 {
2618
2619 run_cost += seq_page_cost * npages;
2620 }
2621
2623 path->startup_cost = startup_cost;
2624 path->total_cost = startup_cost + run_cost;
2625}
References cpu_operator_cost, Path::disabled_nodes, fb(), 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 2525 of file costsize.c.
2530{
2531 RelOptInfo *rel = path->parent;
2532 Cost startup_cost = 0;
2533 Cost run_cost = 0;
2535 double N;
2538
2541
2542 /*
2543 * Avoid log(0)...
2544 */
2547
2548 /* Assumed cost per tuple comparison */
2550
2551 /* Heap creation cost */
2553
2554 /* Per-tuple heap maintenance cost */
2556
2557 /*
2558 * Although MergeAppend does not do any selection or projection, it's not
2559 * free; add a small per-tuple overhead.
2560 */
2562
2563 path->disabled_nodes =
2568}
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 1791 of file costsize.c.
1793{
1794 Cost startup_cost = 0;
1795 Cost run_cost = 0;
1799
1800 /* Should only be applied to base relations that are Tuplestores */
1803
1804 /* Mark the path with the correct row estimate */
1807 else
1809
1810 /* Charge one CPU tuple cost per row for tuplestore manipulation */
1812
1813 /* Add scanning CPU costs */
1815
1816 startup_cost += qpqual_cost.startup;
1819
1822 path->disabled_nodes =
1824 path->startup_cost = startup_cost;
1825 path->total_cost = startup_cost + run_cost;
1826}
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 4899 of file costsize.c.
4900{
4901 cost_qual_eval_context context;
4902 ListCell *l;
4903
4907
4908 /* We don't charge any cost for the implicit ANDing at top level ... */
4909
4910 foreach(l, quals)
4911 {
4913
4914 cost_qual_eval_walker(qual, &context);
4915 }
4916
4917 *cost = context.total;
4918}
static bool cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
Definition costsize.c:4939
Definition costsize.c:169
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 4925 of file costsize.c.
4926{
4927 cost_qual_eval_context context;
4928
4932
4933 cost_qual_eval_walker(qual, &context);
4934
4935 *cost = context.total;
4936}
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 1875 of file costsize.c.
1876{
1877 Cost startup_cost;
1878 Cost total_cost;
1881
1882 /* We probably have decent estimates for the non-recursive term */
1883 startup_cost = nrterm->startup_cost;
1884 total_cost = nrterm->total_cost;
1886
1887 /*
1888 * We arbitrarily assume that about 10 recursive iterations will be
1889 * needed, and that we've managed to get a good fix on the cost and output
1890 * size of each one of them. These are mighty shaky assumptions but it's
1891 * hard to see how to do better.
1892 */
1893 total_cost += 10 * rterm->total_cost;
1895
1896 /*
1897 * Also charge cpu_tuple_cost per row to account for the costs of
1898 * manipulating the tuplestores. (We don't worry about possible
1899 * spill-to-disk costs.)
1900 */
1902
1905 runion->disabled_nodes =
1907 runion->startup_cost = startup_cost;
1908 runion->total_cost = total_cost;
1911 rterm->pathtarget->width);
1912}
References cpu_tuple_cost, fb(), Max, and PGS_CONSIDER_NONPARTIAL.
Referenced by create_recursiveunion_path().
◆ cost_resultscan()
|
extern |
Definition at line 1833 of file costsize.c.
1835{
1836 Cost startup_cost = 0;
1837 Cost run_cost = 0;
1841
1842 /* Should only be applied to RTE_RESULT base relations */
1845
1846 /* Mark the path with the correct row estimate */
1849 else
1851
1852 /* We charge qual cost plus cpu_tuple_cost */
1854
1855 startup_cost += qpqual_cost.startup;
1858
1861 path->disabled_nodes =
1863 path->startup_cost = startup_cost;
1864 path->total_cost = startup_cost + run_cost;
1865}
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 349 of file costsize.c.
351{
352 Cost startup_cost = 0;
353 Cost run_cost = 0;
358 spc_random_page_cost,
359 spc_page_cost;
363
364 /* Should only be applied to base relations with tablesample clauses */
371
372 /* Mark the path with the correct row estimate */
375 else
377
378 /* fetch estimated page cost for tablespace containing table */
380 &spc_random_page_cost,
381 &spc_seq_page_cost);
382
383 /* if NextSampleBlock is used, assume random access, else sequential */
385 spc_random_page_cost : spc_seq_page_cost;
386
387 /*
388 * disk costs (recall that baserel->pages has already been set to the
389 * number of pages the sampling method will visit)
390 */
392
393 /*
394 * CPU costs (recall that baserel->tuples has already been set to the
395 * number of tuples the sampling method will select). Note that we ignore
396 * execution cost of the TABLESAMPLE parameter expressions; they will be
397 * evaluated only once per scan, and in most usages they'll likely be
398 * simple constants anyway. We also don't charge anything for the
399 * calculations the sampling method might do internally.
400 */
402
403 startup_cost += qpqual_cost.startup;
406 /* tlist eval costs are paid per output row, not per tuple scanned */
407 startup_cost += path->pathtarget->cost.startup;
408 run_cost += path->pathtarget->cost.per_tuple * path->rows;
409
412
413 path->disabled_nodes =
415 path->startup_cost = startup_cost;
416 path->total_cost = startup_cost + run_cost;
417}
Definition parsenodes.h:1458
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 270 of file costsize.c.
272{
273 Cost startup_cost = 0;
280
281 /* Should only be applied to base relations */
284
285 /* Mark the path with the correct row estimate */
288 else
290
291 /* fetch estimated page cost for tablespace containing table */
293 NULL,
294 &spc_seq_page_cost);
295
296 /*
297 * disk costs
298 */
300
301 /* CPU costs */
303
304 startup_cost += qpqual_cost.startup;
307 /* tlist eval costs are paid per output row, not per tuple scanned */
308 startup_cost += path->pathtarget->cost.startup;
310
311 /* Adjust costing for parallelism, if used. */
313 {
315
316 /* The CPU cost is divided among all the workers. */
318
319 /*
320 * It may be possible to amortize some of the I/O cost, but probably
321 * not very much, because most operating systems already do aggressive
322 * prefetching. For now, we assume that the disk run cost can't be
323 * amortized at all.
324 */
325
326 /*
327 * In the case of a parallel plan, the row count needs to represent
328 * the number of tuples processed per worker.
329 */
331 }
332 else
334
335 path->disabled_nodes =
337 path->startup_cost = startup_cost;
339}
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 2201 of file costsize.c.
2207{
2208 Cost startup_cost;
2209 Cost run_cost;
2210
2211 cost_tuplesort(&startup_cost, &run_cost,
2212 tuples, width,
2214 limit_tuples);
2215
2216 startup_cost += input_cost;
2217
2218 /*
2219 * We can ignore PGS_CONSIDER_NONPARTIAL here, because if it's relevant,
2220 * it will have already affected the input path.
2221 */
2222 path->rows = tuples;
2224 path->startup_cost = startup_cost;
2225 path->total_cost = startup_cost + run_cost;
2226}
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 4677 of file costsize.c.
4678{
4680
4681 /*
4682 * Figure any cost for evaluating the testexpr.
4683 *
4684 * Usually, SubPlan nodes are built very early, before we have constructed
4685 * any RelOptInfos for the parent query level, which means the parent root
4686 * does not yet contain enough information to safely consult statistics.
4687 * Therefore, we pass root as NULL here. cost_qual_eval() is already
4688 * well-equipped to handle a NULL root.
4689 *
4690 * One exception is SubPlan nodes built for the initplans of MIN/MAX
4691 * aggregates from indexes (cf. SS_make_initplan_from_plan). In this
4692 * case, having a NULL root is safe because testexpr will be NULL.
4693 * Besides, an initplan will by definition not consult anything from the
4694 * parent plan.
4695 */
4698 NULL);
4699
4701 {
4702 /*
4703 * If we are using a hash table for the subquery outputs, then the
4704 * cost of evaluating the query is a one-time cost. We charge one
4705 * cpu_operator_cost per tuple for the work of loading the hashtable,
4706 * too.
4707 */
4710
4711 /*
4712 * The per-tuple costs include the cost of evaluating the lefthand
4713 * expressions, plus the cost of probing the hashtable. We already
4714 * accounted for the lefthand expressions as part of the testexpr, and
4715 * will also have counted one cpu_operator_cost for each comparison
4716 * operator. That is probably too low for the probing cost, but it's
4717 * hard to make a better estimate, so live with it for now.
4718 */
4719 }
4720 else
4721 {
4722 /*
4723 * Otherwise we will be rescanning the subplan output on each
4724 * evaluation. We need to estimate how much of the output we will
4725 * actually need to scan. NOTE: this logic should agree with the
4726 * tuple_fraction estimates used by make_subplan() in
4727 * plan/subselect.c.
4728 */
4730
4732 {
4733 /* we only need to fetch 1 tuple; clamp to avoid zero divide */
4735 }
4738 {
4739 /* assume we need 50% of the tuples */
4741 /* also charge a cpu_operator_cost per row examined */
4743 }
4744 else
4745 {
4746 /* assume we need all tuples */
4748 }
4749
4750 /*
4751 * Also account for subplan's startup cost. If the subplan is
4752 * uncorrelated or undirect correlated, AND its topmost node is one
4753 * that materializes its output, assume that we'll only need to pay
4754 * its startup cost once; otherwise assume we pay the startup cost
4755 * every time.
4756 */
4760 else
4762 }
4763
4766}
Definition primnodes.h:190
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 1478 of file costsize.c.
1481{
1482 Cost startup_cost;
1483 Cost run_cost;
1488
1489 /* Should only be applied to base relations that are subqueries */
1492
1493 /*
1494 * We compute the rowcount estimate as the subplan's estimate times the
1495 * selectivity of relevant restriction clauses. In simple cases this will
1496 * come out the same as baserel->rows; but when dealing with parallelized
1497 * paths we must do it like this to get the right answer.
1498 */
1501 baserel->baserestrictinfo);
1502 else
1504
1507 qpquals,
1508 0,
1509 JOIN_INNER,
1510 NULL));
1511
1512 /*
1513 * Cost of path is cost of evaluating the subplan, plus cost of evaluating
1514 * any restriction clauses and tlist that will be attached to the
1515 * SubqueryScan node, plus cpu_tuple_cost to account for selection and
1516 * projection overhead.
1517 */
1524
1525 /*
1526 * However, if there are no relevant restriction clauses and the
1527 * pathtarget is trivial, then we expect that setrefs.c will optimize away
1528 * the SubqueryScan plan node altogether, so we should just make its cost
1529 * and rowcount equal to the input path's.
1530 *
1531 * Note: there are some edge cases where createplan.c will apply a
1532 * different targetlist to the SubqueryScan node, thus falsifying our
1533 * current estimate of whether the target is trivial, and making the cost
1534 * estimate (though not the rowcount) wrong. It does not seem worth the
1535 * extra complication to try to account for that exactly, especially since
1536 * that behavior falsifies other cost estimates as well.
1537 */
1539 return;
1540
1542
1543 startup_cost = qpqual_cost.startup;
1546
1547 /* tlist eval costs are paid per output row, not per tuple scanned */
1548 startup_cost += path->path.pathtarget->cost.startup;
1550
1553}
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 1629 of file costsize.c.
1631{
1632 Cost startup_cost = 0;
1633 Cost run_cost = 0;
1639
1640 /* Should only be applied to base relations that are functions */
1644
1645 /* Mark the path with the correct row estimate */
1648 else
1650
1651 /*
1652 * Estimate costs of executing the table func expression(s).
1653 *
1654 * XXX in principle we ought to charge tuplestore spill costs if the
1655 * number of rows is large. However, given how phony our rowcount
1656 * estimates for tablefuncs tend to be, there's not a lot of point in that
1657 * refinement right now.
1658 */
1660
1662
1663 /* Add scanning CPU costs */
1665
1666 startup_cost += qpqual_cost.startup;
1669
1670 /* tlist eval costs are paid per output row, not per tuple scanned */
1671 startup_cost += path->pathtarget->cost.startup;
1672 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1673
1676 path->disabled_nodes =
1678 path->startup_cost = startup_cost;
1679 path->total_cost = startup_cost + run_cost;
1680}
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 1361 of file costsize.c.
1364{
1365 Selectivity selectivity;
1366 double pages;
1367 Cost startup_cost;
1373 double ntuples;
1375 double spc_random_page_cost;
1378
1379 /* Should only be applied to base relations */
1382
1383 /* Mark the path with the correct row estimate */
1386 else
1388
1389 /* Count how many tuples and pages we expect to scan */
1393
1394 if (pages <= 0.0)
1395 pages = 1.0;
1396
1397 /*
1398 * The first page in a range requires a random seek, but each subsequent
1399 * page is just a normal sequential page read. NOTE: it's desirable for
1400 * TID Range Scans to cost more than the equivalent Sequential Scans,
1401 * because Seq Scans have some performance advantages such as scan
1402 * synchronization, and we'd prefer one of them to be picked unless a TID
1403 * Range Scan really is better.
1404 */
1405 ntuples = selectivity * baserel->tuples;
1406 nseqpages = pages - 1.0;
1407
1408 /*
1409 * The TID qual expressions will be computed once, any other baserestrict
1410 * quals once per retrieved tuple.
1411 */
1413
1414 /* fetch estimated page cost for tablespace containing table */
1416 &spc_random_page_cost,
1417 &spc_seq_page_cost);
1418
1419 /* disk costs; 1 random page and the remainder as seq pages */
1421
1422 /* Add scanning CPU costs */
1424
1425 /*
1426 * XXX currently we assume TID quals are a subset of qpquals at this
1427 * point; they will be removed (if possible) when we create the plan, so
1428 * we subtract their cost from the total qpqual cost. (If the TID quals
1429 * can't be removed, this is a mistake and we're going to underestimate
1430 * the CPU cost a bit.)
1431 */
1434 tid_qual_cost.per_tuple;
1436
1437 /* tlist eval costs are paid per output row, not per tuple scanned */
1438 startup_cost += path->pathtarget->cost.startup;
1440
1441 /* Adjust costing for parallelism, if used. */
1443 {
1445
1446 /* The CPU cost is divided among all the workers. */
1448
1449 /*
1450 * In the case of a parallel plan, the row count needs to represent
1451 * the number of tuples processed per worker.
1452 */
1454 }
1455
1456 /*
1457 * We should not generate this path type when PGS_TIDSCAN is unset, but we
1458 * might need to disable this path due to PGS_CONSIDER_NONPARTIAL.
1459 */
1463 path->disabled_nodes =
1465 path->startup_cost = startup_cost;
1467}
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 1251 of file costsize.c.
1253{
1254 Cost startup_cost = 0;
1255 Cost run_cost = 0;
1259 double ntuples;
1260 ListCell *l;
1261 double spc_random_page_cost;
1263
1264 /* Should only be applied to base relations */
1268
1269 /* Mark the path with the correct row estimate */
1272 else
1274
1275 /* Count how many tuples we expect to retrieve */
1276 ntuples = 0;
1277 foreach(l, tidquals)
1278 {
1281
1282 /*
1283 * We must use a TID scan for CurrentOfExpr; in any other case, we
1284 * should be generating a TID scan only if TID scans are allowed.
1285 * Also, if CurrentOfExpr is the qual, there should be only one.
1286 */
1289
1291 {
1292 /* Each element of the array yields 1 tuple */
1295
1297 }
1299 {
1300 /* CURRENT OF yields 1 tuple */
1301 ntuples++;
1302 }
1303 else
1304 {
1305 /* It's just CTID = something, count 1 tuple */
1306 ntuples++;
1307 }
1308 }
1309
1310 /*
1311 * The TID qual expressions will be computed once, any other baserestrict
1312 * quals once per retrieved tuple.
1313 */
1315
1316 /* fetch estimated page cost for tablespace containing table */
1318 &spc_random_page_cost,
1319 NULL);
1320
1321 /* disk costs --- assume each tuple on a different page */
1322 run_cost += spc_random_page_cost * ntuples;
1323
1324 /* Add scanning CPU costs */
1326
1327 /* XXX currently we assume TID quals are a subset of qpquals */
1330 tid_qual_cost.per_tuple;
1331 run_cost += cpu_per_tuple * ntuples;
1332
1333 /* tlist eval costs are paid per output row, not per tuple scanned */
1334 startup_cost += path->pathtarget->cost.startup;
1335 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1336
1337 /*
1338 * There are assertions above verifying that we only reach this function
1339 * either when baserel->pgs_mask includes PGS_TIDSCAN or when the TID scan
1340 * is the only legal path, so we only need to consider the effects of
1341 * PGS_CONSIDER_NONPARTIAL here.
1342 */
1345 path->disabled_nodes =
1347 path->startup_cost = startup_cost;
1348 path->total_cost = startup_cost + run_cost;
1349}
double estimate_array_length(PlannerInfo *root, Node *arrayexpr)
Definition selfuncs.c:2240
Definition primnodes.h:2122
Definition primnodes.h:927
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 1690 of file costsize.c.
1692{
1693 Cost startup_cost = 0;
1694 Cost run_cost = 0;
1698
1699 /* Should only be applied to base relations that are values lists */
1702
1703 /* Mark the path with the correct row estimate */
1706 else
1708
1709 /*
1710 * For now, estimate list evaluation cost at one operator eval per list
1711 * (probably pretty bogus, but is it worth being smarter?)
1712 */
1714
1715 /* Add scanning CPU costs */
1717
1718 startup_cost += qpqual_cost.startup;
1721
1722 /* tlist eval costs are paid per output row, not per tuple scanned */
1723 startup_cost += path->pathtarget->cost.startup;
1724 run_cost += path->pathtarget->cost.per_tuple * path->rows;
1725
1728 path->disabled_nodes =
1730 path->startup_cost = startup_cost;
1731 path->total_cost = startup_cost + run_cost;
1732}
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 3204 of file costsize.c.
3209{
3210 Cost startup_cost;
3211 Cost total_cost;
3216
3219
3220 startup_cost = input_startup_cost;
3221 total_cost = input_total_cost;
3222
3223 /*
3224 * Window functions are assumed to cost their stated execution cost, plus
3225 * the cost of evaluating their input expressions, per tuple. Since they
3226 * may in fact evaluate their inputs at multiple rows during each cycle,
3227 * this could be a drastic underestimate; but without a way to know how
3228 * many rows the window function will fetch, it's hard to do better. In
3229 * any case, it's a good estimate for all the built-in window functions,
3230 * so we'll just do this for now.
3231 */
3233 {
3237
3240 &argcosts);
3241 startup_cost += argcosts.startup;
3243
3244 /* also add the input expressions' cost to per-input-row costs */
3246 startup_cost += argcosts.startup;
3248
3249 /*
3250 * Add the filter's cost to per-input-row costs. XXX We should reduce
3251 * input expression costs according to filter selectivity.
3252 */
3254 startup_cost += argcosts.startup;
3256
3257 total_cost += wfunccost * input_tuples;
3258 }
3259
3260 /*
3261 * We also charge cpu_operator_cost per grouping column per tuple for
3262 * grouping comparisons, plus cpu_tuple_cost per tuple for general
3263 * overhead.
3264 *
3265 * XXX this neglects costs of spooling the data to disk when it overflows
3266 * work_mem. Sooner or later that should get accounted for.
3267 */
3269 total_cost += cpu_tuple_cost * input_tuples;
3270
3271 path->rows = input_tuples;
3273 path->startup_cost = startup_cost;
3274 path->total_cost = total_cost;
3275
3276 /*
3277 * Also, take into account how many tuples we need to read from the
3278 * subnode in order to produce the first tuple from the WindowAgg. To do
3279 * this we proportion the run cost (total cost not including startup cost)
3280 * over the estimated startup tuples. We already included the startup
3281 * cost of the subnode, so we only need to do this when the estimated
3282 * startup tuples is above 1.0.
3283 */
3285 input_tuples);
3286
3288 path->startup_cost += (total_cost - startup_cost) / input_tuples *
3289 (startup_tuples - 1.0);
3290}
static double get_windowclause_startup_tuples(PlannerInfo *root, WindowClause *wc, double input_tuples)
Definition costsize.c:2990
void add_function_cost(PlannerInfo *root, Oid funcid, Node *node, QualCost *cost)
Definition plancat.c:2355
Definition primnodes.h:595
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 4416 of file costsize.c.
4419{
4438
4439 /* Set the number of disabled nodes. */
4441
4442 /* Mark the path with the correct row estimate */
4445 else
4447
4448 /* For partial paths, scale row estimate. */
4450 {
4452
4453 path->jpath.path.rows =
4455 }
4456
4457 /* mark the path with estimated # of batches */
4458 path->num_batches = numbatches;
4459
4460 /* store the total number of tuples (sum of partial row estimates) */
4462
4463 /* and compute the number of "virtual" buckets in the whole join */
4465
4466 /*
4467 * Determine bucketsize fraction and MCV frequency for the inner relation.
4468 * We use the smallest bucketsize or MCV frequency estimated for any
4469 * individual hashclause; this is undoubtedly conservative.
4470 *
4471 * BUT: if inner relation has been unique-ified, we can assume it's good
4472 * for hashing. This is important both because it's the right answer, and
4473 * because we avoid contaminating the cache with a value that's wrong for
4474 * non-unique-ified paths.
4475 */
4478 {
4481 }
4482 else
4483 {
4485
4486 innerbucketsize = 1.0;
4487 innermcvfreq = 1.0;
4488
4489 /* At first, try to estimate bucket size using extended statistics. */
4491 inner_path->parent,
4492 hashclauses,
4493 &innerbucketsize);
4494
4495 /* Pass through the remaining clauses */
4497 {
4501
4502 /*
4503 * First we have to figure out which side of the hashjoin clause
4504 * is the inner side.
4505 *
4506 * Since we tend to visit the same clauses over and over when
4507 * planning a large query, we cache the bucket stats estimates in
4508 * the RestrictInfo node to avoid repeated lookups of statistics.
4509 */
4511 inner_path->parent->relids))
4512 {
4513 /* righthand side is inner */
4516 {
4517 /* not cached yet */
4520 virtualbuckets,
4521 &restrictinfo->right_mcvfreq,
4522 &restrictinfo->right_bucketsize);
4524 }
4526 }
4527 else
4528 {
4530 inner_path->parent->relids));
4531 /* lefthand side is inner */
4534 {
4535 /* not cached yet */
4538 virtualbuckets,
4539 &restrictinfo->left_mcvfreq,
4540 &restrictinfo->left_bucketsize);
4542 }
4544 }
4545
4548 /* Disregard zero for MCV freq, it means we have no data */
4551 }
4552 }
4553
4554 /*
4555 * If the bucket holding the inner MCV would exceed hash_mem, we don't
4556 * want to hash unless there is really no other alternative, so apply
4557 * disable_cost. (The executor normally copes with excessive memory usage
4558 * by splitting batches, but obviously it cannot separate equal values
4559 * that way, so it will be unable to drive the batch size below hash_mem
4560 * when this is true.)
4561 */
4564 startup_cost += disable_cost;
4565
4566 /*
4567 * Compute cost of the hashquals and qpquals (other restriction clauses)
4568 * separately.
4569 */
4574
4575 /* CPU costs */
4576
4579 extra->inner_unique)
4580 {
4583
4584 /*
4585 * With a SEMI or ANTI join, or if the innerrel is known unique, the
4586 * executor will stop after the first match.
4587 *
4588 * For an outer-rel row that has at least one match, we can expect the
4589 * bucket scan to stop after a fraction 1/(match_count+1) of the
4590 * bucket's rows, if the matches are evenly distributed. Since they
4591 * probably aren't quite evenly distributed, we apply a fuzz factor of
4592 * 2.0 to that fraction. (If we used a larger fuzz factor, we'd have
4593 * to clamp inner_scan_frac to at most 1.0; but since match_count is
4594 * at least 1, no such clamp is needed now.)
4595 */
4598
4599 startup_cost += hash_qual_cost.startup;
4602
4603 /*
4604 * For unmatched outer-rel rows, the picture is quite a lot different.
4605 * In the first place, there is no reason to assume that these rows
4606 * preferentially hit heavily-populated buckets; instead assume they
4607 * are uncorrelated with the inner distribution and so they see an
4608 * average bucket size of inner_path_rows / virtualbuckets. In the
4609 * second place, it seems likely that they will have few if any exact
4610 * hash-code matches and so very few of the tuples in the bucket will
4611 * actually require eval of the hash quals. We don't have any good
4612 * way to estimate how many will, but for the moment assume that the
4613 * effective cost per bucket entry is one-tenth what it is for
4614 * matchable tuples.
4615 */
4616 run_cost += hash_qual_cost.per_tuple *
4619
4620 /* Get # of tuples that will pass the basic join */
4623 else
4625 }
4626 else
4627 {
4628 /*
4629 * The number of tuple comparisons needed is the number of outer
4630 * tuples times the typical number of tuples in a hash bucket, which
4631 * is the inner relation size times its bucketsize fraction. At each
4632 * one, we need to evaluate the hashjoin quals. But actually,
4633 * charging the full qual eval cost at each tuple is pessimistic,
4634 * since we don't evaluate the quals unless the hash values match
4635 * exactly. For lack of a better idea, halve the cost estimate to
4636 * allow for that.
4637 */
4638 startup_cost += hash_qual_cost.startup;
4641
4642 /*
4643 * Get approx # tuples passing the hashquals. We use
4644 * approx_tuple_count here because we need an estimate done with
4645 * JOIN_INNER semantics.
4646 */
4648 }
4649
4650 /*
4651 * For each tuple that gets through the hashjoin proper, we charge
4652 * cpu_tuple_cost plus the cost of evaluating additional restriction
4653 * clauses that are to be applied at the join. (This is pessimistic since
4654 * not all of the quals may get evaluated at each tuple.)
4655 */
4656 startup_cost += qp_qual_cost.startup;
4659
4660 /* tlist eval costs are paid per output row, not per tuple scanned */
4661 startup_cost += path->jpath.path.pathtarget->cost.startup;
4663
4664 path->jpath.path.startup_cost = startup_cost;
4665 path->jpath.path.total_cost = startup_cost + run_cost;
4666}
static double approx_tuple_count(PlannerInfo *root, JoinPath *path, List *quals)
Definition costsize.c:5447
#define RELATION_WAS_MADE_UNIQUE(rel, sjinfo, nominal_jointype)
Definition pathnodes.h:1238
List * estimate_multivariate_bucketsize(PlannerInfo *root, RelOptInfo *inner, List *hashclauses, Selectivity *innerbucketsize)
Definition selfuncs.c:4140
void estimate_hash_bucket_stats(PlannerInfo *root, Node *hashkey, double nbuckets, Selectivity *mcv_freq, Selectivity *bucketsize_frac)
Definition selfuncs.c:4408
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 3955 of file costsize.c.
3958{
3972 bare_inner_cost,
3973 mat_inner_cost;
3977 rescannedtuples;
3980
3981 /* Protect some assumptions below that rowcounts aren't zero */
3983 inner_path_rows = 1;
3984
3985 /* Mark the path with the correct row estimate */
3988 else
3990
3991 /* For partial paths, scale row estimate. */
3993 {
3995
3996 path->jpath.path.rows =
3998 }
3999
4000 /*
4001 * Compute cost of the mergequals and qpquals (other restriction clauses)
4002 * separately.
4003 */
4008
4009 /*
4010 * With a SEMI or ANTI join, or if the innerrel is known unique, the
4011 * executor will stop scanning for matches after the first match. When
4012 * all the joinclauses are merge clauses, this means we don't ever need to
4013 * back up the merge, and so we can skip mark/restore overhead.
4014 */
4017 extra->inner_unique) &&
4021 else
4023
4024 /*
4025 * Get approx # tuples passing the mergequals. We use approx_tuple_count
4026 * here because we need an estimate done with JOIN_INNER semantics.
4027 */
4029
4030 /*
4031 * When there are equal merge keys in the outer relation, the mergejoin
4032 * must rescan any matching tuples in the inner relation. This means
4033 * re-fetching inner tuples; we have to estimate how often that happens.
4034 *
4035 * For regular inner and outer joins, the number of re-fetches can be
4036 * estimated approximately as size of merge join output minus size of
4037 * inner relation. Assume that the distinct key values are 1, 2, ..., and
4038 * denote the number of values of each key in the outer relation as m1,
4039 * m2, ...; in the inner relation, n1, n2, ... Then we have
4040 *
4041 * size of join = m1 * n1 + m2 * n2 + ...
4042 *
4043 * number of rescanned tuples = (m1 - 1) * n1 + (m2 - 1) * n2 + ... = m1 *
4044 * n1 + m2 * n2 + ... - (n1 + n2 + ...) = size of join - size of inner
4045 * relation
4046 *
4047 * This equation works correctly for outer tuples having no inner match
4048 * (nk = 0), but not for inner tuples having no outer match (mk = 0); we
4049 * are effectively subtracting those from the number of rescanned tuples,
4050 * when we should not. Can we do better without expensive selectivity
4051 * computations?
4052 *
4053 * The whole issue is moot if we know we don't need to mark/restore at
4054 * all, or if we are working from a unique-ified outer input.
4055 */
4059 rescannedtuples = 0;
4060 else
4061 {
4063 /* Must clamp because of possible underestimate */
4065 rescannedtuples = 0;
4066 }
4067
4068 /*
4069 * We'll inflate various costs this much to account for rescanning. Note
4070 * that this is to be multiplied by something involving inner_rows, or
4071 * another number related to the portion of the inner rel we'll scan.
4072 */
4074
4075 /*
4076 * Decide whether we want to materialize the inner input to shield it from
4077 * mark/restore and performing re-fetches. Our cost model for regular
4078 * re-fetches is that a re-fetch costs the same as an original fetch,
4079 * which is probably an overestimate; but on the other hand we ignore the
4080 * bookkeeping costs of mark/restore. Not clear if it's worth developing
4081 * a more refined model. So we just need to inflate the inner run cost by
4082 * rescanratio.
4083 */
4085
4086 /*
4087 * When we interpose a Material node the re-fetch cost is assumed to be
4088 * just cpu_operator_cost per tuple, independently of the underlying
4089 * plan's cost; and we charge an extra cpu_operator_cost per original
4090 * fetch as well. Note that we're assuming the materialize node will
4091 * never spill to disk, since it only has to remember tuples back to the
4092 * last mark. (If there are a huge number of duplicates, our other cost
4093 * factors will make the path so expensive that it probably won't get
4094 * chosen anyway.) So we don't use cost_rescan here.
4095 *
4096 * Note: keep this estimate in sync with create_mergejoin_plan's labeling
4097 * of the generated Material node.
4098 */
4099 mat_inner_cost = inner_run_cost +
4101
4102 /*
4103 * If we don't need mark/restore at all, we don't need materialization.
4104 */
4107
4108 /*
4109 * If merge joins with materialization are enabled, then choose
4110 * materialization if either (a) it looks cheaper or (b) merge joins
4111 * without materialization are disabled.
4112 */
4117
4118 /*
4119 * Regardless of what plan shapes are enabled and what the costs seem to
4120 * be, we *must* materialize it if the inner path is to be used directly
4121 * (without sorting) and it doesn't support mark/restore. Planner failure
4122 * is not an option!
4123 *
4124 * Since the inner side must be ordered, and only Sorts and IndexScans can
4125 * create order to begin with, and they both support mark/restore, you
4126 * might think there's no problem --- but you'd be wrong. Nestloop and
4127 * merge joins can *preserve* the order of their inputs, so they can be
4128 * selected as the input of a mergejoin, and they don't support
4129 * mark/restore at present.
4130 */
4134
4135 /*
4136 * Also, force materializing if the inner path is to be sorted and the
4137 * sort is expected to spill to disk. This is because the final merge
4138 * pass can be done on-the-fly if it doesn't have to support mark/restore.
4139 * We don't try to adjust the cost estimates for this consideration,
4140 * though.
4141 *
4142 * Since materialization is a performance optimization in this case,
4143 * rather than necessary for correctness, we skip it if materialization is
4144 * switched off.
4145 */
4147 innersortkeys != NIL &&
4149 inner_path->pathtarget->width) >
4152 else
4154
4155 /* Get the number of disabled nodes, not yet including this one. */
4157
4158 /*
4159 * Charge the right incremental cost for the chosen case, and update
4160 * enable_mask as appropriate.
4161 */
4163 {
4164 run_cost += mat_inner_cost;
4166 }
4167 else
4168 {
4169 run_cost += bare_inner_cost;
4171 }
4172
4173 /* Incremental count of disabled nodes if this node is disabled. */
4177 ++path->jpath.path.disabled_nodes;
4178
4179 /* CPU costs */
4180
4181 /*
4182 * The number of tuple comparisons needed is approximately number of outer
4183 * rows plus number of inner rows plus number of rescanned tuples (can we
4184 * refine this?). At each one, we need to evaluate the mergejoin quals.
4185 */
4186 startup_cost += merge_qual_cost.startup;
4187 startup_cost += merge_qual_cost.per_tuple *
4188 (outer_skip_rows + inner_skip_rows * rescanratio);
4189 run_cost += merge_qual_cost.per_tuple *
4190 ((outer_rows - outer_skip_rows) +
4191 (inner_rows - inner_skip_rows) * rescanratio);
4192
4193 /*
4194 * For each tuple that gets through the mergejoin proper, we charge
4195 * cpu_tuple_cost plus the cost of evaluating additional restriction
4196 * clauses that are to be applied at the join. (This is pessimistic since
4197 * not all of the quals may get evaluated at each tuple.)
4198 *
4199 * Note: we could adjust for SEMI/ANTI joins skipping some qual
4200 * evaluations here, but it's probably not worth the trouble.
4201 */
4202 startup_cost += qp_qual_cost.startup;
4205
4206 /* tlist eval costs are paid per output row, not per tuple scanned */
4207 startup_cost += path->jpath.path.pathtarget->cost.startup;
4209
4210 path->jpath.path.startup_cost = startup_cost;
4211 path->jpath.path.total_cost = startup_cost + run_cost;
4212}
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 3455 of file costsize.c.
3458{
3467 double ntuples;
3468
3469 /* Set the number of disabled nodes. */
3471
3472 /* Protect some assumptions below that rowcounts aren't zero */
3474 outer_path_rows = 1;
3476 inner_path_rows = 1;
3477 /* Mark the path with the correct row estimate */
3480 else
3482
3483 /* For partial paths, scale row estimate. */
3485 {
3487
3488 path->jpath.path.rows =
3490 }
3491
3492 /* cost of inner-relation source data (we already dealt with outer rel) */
3493
3495 extra->inner_unique)
3496 {
3497 /*
3498 * With a SEMI or ANTI join, or if the innerrel is known unique, the
3499 * executor will stop after the first match.
3500 */
3506
3507 /*
3508 * For an outer-rel row that has at least one match, we can expect the
3509 * inner scan to stop after a fraction 1/(match_count+1) of the inner
3510 * rows, if the matches are evenly distributed. Since they probably
3511 * aren't quite evenly distributed, we apply a fuzz factor of 2.0 to
3512 * that fraction. (If we used a larger fuzz factor, we'd have to
3513 * clamp inner_scan_frac to at most 1.0; but since match_count is at
3514 * least 1, no such clamp is needed now.)
3515 */
3519
3520 /*
3521 * Compute number of tuples processed (not number emitted!). First,
3522 * account for successfully-matched outer rows.
3523 */
3525
3526 /*
3527 * Now we need to estimate the actual costs of scanning the inner
3528 * relation, which may be quite a bit less than N times inner_run_cost
3529 * due to early scan stops. We consider two cases. If the inner path
3530 * is an indexscan using all the joinquals as indexquals, then an
3531 * unmatched outer row results in an indexscan returning no rows,
3532 * which is probably quite cheap. Otherwise, the executor will have
3533 * to scan the whole inner rel for an unmatched row; not so cheap.
3534 */
3536 {
3537 /*
3538 * Successfully-matched outer rows will only require scanning
3539 * inner_scan_frac of the inner relation. In this case, we don't
3540 * need to charge the full inner_run_cost even when that's more
3541 * than inner_rescan_run_cost, because we can assume that none of
3542 * the inner scans ever scan the whole inner relation. So it's
3543 * okay to assume that all the inner scan executions can be
3544 * fractions of the full cost, even if materialization is reducing
3545 * the rescan cost. At this writing, it's impossible to get here
3546 * for a materialized inner scan, so inner_run_cost and
3547 * inner_rescan_run_cost will be the same anyway; but just in
3548 * case, use inner_run_cost for the first matched tuple and
3549 * inner_rescan_run_cost for additional ones.
3550 */
3551 run_cost += inner_run_cost * inner_scan_frac;
3554
3555 /*
3556 * Add the cost of inner-scan executions for unmatched outer rows.
3557 * We estimate this as the same cost as returning the first tuple
3558 * of a nonempty scan. We consider that these are all rescans,
3559 * since we used inner_run_cost once already.
3560 */
3561 run_cost += outer_unmatched_rows *
3562 inner_rescan_run_cost / inner_path_rows;
3563
3564 /*
3565 * We won't be evaluating any quals at all for unmatched rows, so
3566 * don't add them to ntuples.
3567 */
3568 }
3569 else
3570 {
3571 /*
3572 * Here, a complicating factor is that rescans may be cheaper than
3573 * first scans. If we never scan all the way to the end of the
3574 * inner rel, it might be (depending on the plan type) that we'd
3575 * never pay the whole inner first-scan run cost. However it is
3576 * difficult to estimate whether that will happen (and it could
3577 * not happen if there are any unmatched outer rows!), so be
3578 * conservative and always charge the whole first-scan cost once.
3579 * We consider this charge to correspond to the first unmatched
3580 * outer row, unless there isn't one in our estimate, in which
3581 * case blame it on the first matched row.
3582 */
3583
3584 /* First, count all unmatched join tuples as being processed */
3586
3587 /* Now add the forced full scan, and decrement appropriate count */
3588 run_cost += inner_run_cost;
3590 outer_unmatched_rows -= 1;
3591 else
3592 outer_matched_rows -= 1;
3593
3594 /* Add inner run cost for additional outer tuples having matches */
3597
3598 /* Add inner run cost for additional unmatched outer tuples */
3600 run_cost += outer_unmatched_rows * inner_rescan_run_cost;
3601 }
3602 }
3603 else
3604 {
3605 /* Normal-case source costs were included in preliminary estimate */
3606
3607 /* Compute number of tuples processed (not number emitted!) */
3609 }
3610
3611 /* CPU costs */
3613 startup_cost += restrict_qual_cost.startup;
3615 run_cost += cpu_per_tuple * ntuples;
3616
3617 /* tlist eval costs are paid per output row, not per tuple scanned */
3618 startup_cost += path->jpath.path.pathtarget->cost.startup;
3620
3621 path->jpath.path.startup_cost = startup_cost;
3622 path->jpath.path.total_cost = startup_cost + run_cost;
3623}
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 5522 of file costsize.c.
5524{
5526 double nrows;
5527
5528 /*
5529 * Estimate the number of rows returned by the parameterized scan, knowing
5530 * that it will apply all the extra join clauses as well as the rel's own
5531 * restriction clauses. Note that we force the clauses to be treated as
5532 * non-join clauses during selectivity estimation.
5533 */
5535 nrows = rel->tuples *
5537 allclauses,
5539 JOIN_INNER,
5540 NULL);
5541 nrows = clamp_row_est(nrows);
5542 /* For safety, make sure result is not more than the base estimate */
5544 nrows = rel->rows;
5545 return nrows;
5546}
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 5603 of file costsize.c.
5608{
5609 double nrows;
5610
5611 /*
5612 * Estimate the number of rows returned by the parameterized join as the
5613 * sizes of the input paths times the selectivity of the clauses that have
5614 * ended up at this join node.
5615 *
5616 * As with set_joinrel_size_estimates, the rowcount estimate could depend
5617 * on the pair of input paths provided, though ideally we'd get the same
5618 * estimate for any pair with the same parameterization.
5619 */
5621 rel,
5622 outer_path->parent,
5623 inner_path->parent,
5624 outer_path->rows,
5625 inner_path->rows,
5626 sjinfo,
5627 restrict_clauses);
5628 /* For safety, make sure result is not more than the base estimate */
5630 nrows = rel->rows;
5631 return nrows;
5632}
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:5644
References calc_joinrel_size_estimate(), fb(), root, and RelOptInfo::rows.
Referenced by get_joinrel_parampathinfo().
◆ index_pages_fetched()
|
extern |
Definition at line 897 of file costsize.c.
899{
903 b;
904
905 /* T is # pages in table, but don't allow it to be zero */
907
908 /* Compute number of pages assumed to be competing for cache space */
912
913 /* b is pro-rated share of effective_cache_size */
915
916 /* force it positive and integral */
918 b = 1.0;
919 else
921
922 /* This part is the Mackert and Lohman formula */
924 {
925 pages_fetched =
929 else
931 }
932 else
933 {
935
938 {
939 pages_fetched =
941 }
942 else
943 {
944 pages_fetched =
946 }
948 }
950}
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 4297 of file costsize.c.
4303{
4304 int disabled_nodes;
4305 Cost startup_cost = 0;
4306 Cost run_cost = 0;
4311 int numbuckets;
4312 int numbatches;
4314 size_t space_allowed; /* unused */
4316
4319
4320 /* Count up disabled nodes. */
4322 disabled_nodes += inner_path->disabled_nodes;
4323 disabled_nodes += outer_path->disabled_nodes;
4324
4325 /* cost of source data */
4326 startup_cost += outer_path->startup_cost;
4328 startup_cost += inner_path->total_cost;
4329
4330 /*
4331 * Cost of computing hash function: must do it once per input tuple. We
4332 * charge one cpu_operator_cost for each column's hash function. Also,
4333 * tack on one cpu_tuple_cost per inner row, to model the costs of
4334 * inserting the row into the hashtable.
4335 *
4336 * XXX when a hashclause is more complex than a single operator, we really
4337 * should charge the extra eval costs of the left or right side, as
4338 * appropriate, here. This seems more work than it's worth at the moment.
4339 */
4341 * inner_path_rows;
4343
4344 /*
4345 * If this is a parallel hash build, then the value we have for
4346 * inner_rows_total currently refers only to the rows returned by each
4347 * participant. For shared hash table size estimation, we need the total
4348 * number, so we need to undo the division.
4349 */
4352
4353 /*
4354 * Get hash table size that executor would use for inner relation.
4355 *
4356 * XXX for the moment, always assume that skew optimization will be
4357 * performed. As long as SKEW_HASH_MEM_PERCENT is small, it's not worth
4358 * trying to determine that for sure.
4359 *
4360 * XXX at some point it might be interesting to try to account for skew
4361 * optimization in the cost estimate, but for now, we don't.
4362 */
4364 inner_path->pathtarget->width,
4365 true, /* useskew */
4367 outer_path->parallel_workers,
4368 &space_allowed,
4369 &numbuckets,
4370 &numbatches,
4371 &num_skew_mcvs);
4372
4373 /*
4374 * If inner relation is too big then we will need to "batch" the join,
4375 * which implies writing and reading most of the tuples to disk an extra
4376 * time. Charge seq_page_cost per page, since the I/O should be nice and
4377 * sequential. Writing the inner rel counts as startup cost, all the rest
4378 * as run cost.
4379 */
4380 if (numbatches > 1)
4381 {
4383 outer_path->pathtarget->width);
4385 inner_path->pathtarget->width);
4386
4389 }
4390
4391 /* CPU costs left for later */
4392
4393 /* Public result fields */
4394 workspace->disabled_nodes = disabled_nodes;
4395 workspace->startup_cost = startup_cost;
4396 workspace->total_cost = startup_cost + run_cost;
4397 /* Save private data for final_cost_hashjoin */
4398 workspace->run_cost = run_cost;
4399 workspace->numbuckets = numbuckets;
4400 workspace->numbatches = numbatches;
4402}
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:658
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 3658 of file costsize.c.
3665{
3666 int disabled_nodes;
3667 Cost startup_cost = 0;
3668 Cost run_cost = 0;
3671 Cost inner_run_cost;
3672 double outer_rows,
3673 inner_rows,
3674 outer_skip_rows,
3675 inner_skip_rows;
3677 outerendsel,
3678 innerstartsel,
3679 innerendsel;
3681 * cost_sort/cost_incremental_sort */
3682
3683 /* Protect some assumptions below that rowcounts aren't zero */
3685 outer_path_rows = 1;
3687 inner_path_rows = 1;
3688
3689 /*
3690 * A merge join will stop as soon as it exhausts either input stream
3691 * (unless it's an outer join, in which case the outer side has to be
3692 * scanned all the way anyway). Estimate fraction of the left and right
3693 * inputs that will actually need to be scanned. Likewise, we can
3694 * estimate the number of rows that will be skipped before the first join
3695 * pair is found, which should be factored into startup cost. We use only
3696 * the first (most significant) merge clause for this purpose. Since
3697 * mergejoinscansel() is a fairly expensive computation, we cache the
3698 * results in the merge clause RestrictInfo.
3699 */
3701 {
3707 MergeScanSelCache *cache;
3708
3709 /* Get the input pathkeys to determine the sort-order details */
3716 /* debugging check */
3722
3723 /* Get the selectivity with caching */
3725
3727 outer_path->parent->relids))
3728 {
3729 /* left side of clause is outer */
3734 }
3735 else
3736 {
3737 /* left side of clause is inner */
3742 }
3744 jointype == JOIN_ANTI)
3745 {
3746 outerstartsel = 0.0;
3747 outerendsel = 1.0;
3748 }
3750 jointype == JOIN_RIGHT_ANTI)
3751 {
3752 innerstartsel = 0.0;
3753 innerendsel = 1.0;
3754 }
3755 }
3756 else
3757 {
3758 /* cope with clauseless or full mergejoin */
3761 }
3762
3763 /*
3764 * Convert selectivities to row counts. We force outer_rows and
3765 * inner_rows to be at least 1, but the skip_rows estimates can be zero.
3766 */
3771
3772 Assert(outer_skip_rows <= outer_rows);
3773 Assert(inner_skip_rows <= inner_rows);
3774
3775 /*
3776 * Readjust scan selectivities to account for above rounding. This is
3777 * normally an insignificant effect, but when there are only a few rows in
3778 * the inputs, failing to do this makes for a large percentage error.
3779 */
3784
3787
3788 /*
3789 * We don't decide whether to materialize the inner path until we get to
3790 * final_cost_mergejoin(), so we don't know whether to check the pgs_mask
3791 * against PGS_MERGEJOIN_PLAIN or PGS_MERGEJOIN_MATERIALIZE. Instead, we
3792 * just account for any child nodes here and assume that this node is not
3793 * itself disabled; we can sort out the details in final_cost_mergejoin().
3794 *
3795 * (We could be more precise here by setting disabled_nodes to 1 at this
3796 * stage if both PGS_MERGEJOIN_PLAIN and PGS_MERGEJOIN_MATERIALIZE are
3797 * disabled, but that seems to against the idea of making this function
3798 * produce a quick, optimistic approximation of the final cost.)
3799 */
3800 disabled_nodes = 0;
3801
3802 /* cost of source data */
3803
3804 if (outersortkeys) /* do we need to sort outer? */
3805 {
3806 /*
3807 * We can assert that the outer path is not already ordered
3808 * appropriately for the mergejoin; otherwise, outersortkeys would
3809 * have been set to NIL.
3810 */
3812
3813 /*
3814 * We choose to use incremental sort if it is enabled and there are
3815 * presorted keys; otherwise we use full sort.
3816 */
3818 {
3820 root,
3821 outersortkeys,
3822 outer_presorted_keys,
3823 outer_path->disabled_nodes,
3824 outer_path->startup_cost,
3825 outer_path->total_cost,
3826 outer_path_rows,
3827 outer_path->pathtarget->width,
3828 0.0,
3829 work_mem,
3830 -1.0);
3831 }
3832 else
3833 {
3835 root,
3836 outersortkeys,
3837 outer_path->disabled_nodes,
3838 outer_path->total_cost,
3839 outer_path_rows,
3840 outer_path->pathtarget->width,
3841 0.0,
3842 work_mem,
3843 -1.0);
3844 }
3845
3846 disabled_nodes += sort_path.disabled_nodes;
3847 startup_cost += sort_path.startup_cost;
3849 * outerstartsel;
3852 }
3853 else
3854 {
3855 disabled_nodes += outer_path->disabled_nodes;
3856 startup_cost += outer_path->startup_cost;
3858 * outerstartsel;
3861 }
3862
3863 if (innersortkeys) /* do we need to sort inner? */
3864 {
3865 /*
3866 * We can assert that the inner path is not already ordered
3867 * appropriately for the mergejoin; otherwise, innersortkeys would
3868 * have been set to NIL.
3869 */
3871
3872 /*
3873 * We do not consider incremental sort for inner path, because
3874 * incremental sort does not support mark/restore.
3875 */
3876
3878 root,
3879 innersortkeys,
3880 inner_path->disabled_nodes,
3881 inner_path->total_cost,
3882 inner_path_rows,
3883 inner_path->pathtarget->width,
3884 0.0,
3885 work_mem,
3886 -1.0);
3887 disabled_nodes += sort_path.disabled_nodes;
3888 startup_cost += sort_path.startup_cost;
3890 * innerstartsel;
3893 }
3894 else
3895 {
3896 disabled_nodes += inner_path->disabled_nodes;
3897 startup_cost += inner_path->startup_cost;
3899 * innerstartsel;
3902 }
3903
3904 /*
3905 * We can't yet determine whether rescanning occurs, or whether
3906 * materialization of the inner input should be done. The minimum
3907 * possible inner input cost, regardless of rescan and materialization
3908 * considerations, is inner_run_cost. We include that in
3909 * workspace->total_cost, but not yet in run_cost.
3910 */
3911
3912 /* CPU costs left for later */
3913
3914 /* Public result fields */
3915 workspace->disabled_nodes = disabled_nodes;
3916 workspace->startup_cost = startup_cost;
3917 workspace->total_cost = startup_cost + run_cost + inner_run_cost;
3918 /* Save private data for final_cost_mergejoin */
3919 workspace->run_cost = run_cost;
3920 workspace->inner_run_cost = inner_run_cost;
3921 workspace->outer_rows = outer_rows;
3922 workspace->inner_rows = inner_rows;
3923 workspace->outer_skip_rows = outer_skip_rows;
3924 workspace->inner_skip_rows = inner_skip_rows;
3925}
static MergeScanSelCache * cached_scansel(PlannerInfo *root, RestrictInfo *rinfo, PathKey *pathkey)
Definition costsize.c:4218
Definition pathnodes.h:3057
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 3373 of file costsize.c.
3377{
3378 int disabled_nodes;
3379 Cost startup_cost = 0;
3380 Cost run_cost = 0;
3384 Cost inner_run_cost;
3385 Cost inner_rescan_run_cost;
3386
3387 /* Count up disabled nodes. */
3389 disabled_nodes += inner_path->disabled_nodes;
3390 disabled_nodes += outer_path->disabled_nodes;
3391
3392 /* estimate costs to rescan the inner relation */
3394 &inner_rescan_start_cost,
3395 &inner_rescan_total_cost);
3396
3397 /* cost of source data */
3398
3399 /*
3400 * NOTE: clearly, we must pay both outer and inner paths' startup_cost
3401 * before we can start returning tuples, so the join's startup cost is
3402 * their sum. We'll also pay the inner path's rescan startup cost
3403 * multiple times.
3404 */
3409
3412
3414 extra->inner_unique)
3415 {
3416 /*
3417 * With a SEMI or ANTI join, or if the innerrel is known unique, the
3418 * executor will stop after the first match.
3419 *
3420 * Getting decent estimates requires inspection of the join quals,
3421 * which we choose to postpone to final_cost_nestloop.
3422 */
3423
3424 /* Save private data for final_cost_nestloop */
3425 workspace->inner_run_cost = inner_run_cost;
3426 workspace->inner_rescan_run_cost = inner_rescan_run_cost;
3427 }
3428 else
3429 {
3430 /* Normal case; we'll scan whole input rel for each outer row */
3431 run_cost += inner_run_cost;
3433 run_cost += (outer_path_rows - 1) * inner_rescan_run_cost;
3434 }
3435
3436 /* CPU costs left for later */
3437
3438 /* Public result fields */
3439 workspace->disabled_nodes = disabled_nodes;
3440 workspace->startup_cost = startup_cost;
3441 workspace->total_cost = startup_cost + run_cost;
3442 /* Save private data for final_cost_nestloop */
3443 workspace->run_cost = run_cost;
3444}
static void cost_rescan(PlannerInfo *root, Path *path, Cost *rescan_startup_cost, Cost *rescan_total_cost)
Definition costsize.c:4784
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 5492 of file costsize.c.
5493{
5494 double nrows;
5495
5496 /* Should only be applied to base relations */
5498
5499 nrows = rel->tuples *
5501 rel->baserestrictinfo,
5502 0,
5503 JOIN_INNER,
5504 NULL);
5505
5507
5509
5511}
static void set_rel_width(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:6353
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 6218 of file costsize.c.
6219{
6221
6222 /* Should only be applied to base relations that are CTE references */
6226
6228 {
6229 /*
6230 * In a self-reference, we assume the average worktable size is a
6231 * multiple of the nonrecursive term's size. The best multiplier will
6232 * vary depending on query "fan-out", so make its value adjustable.
6233 */
6235 }
6236 else
6237 {
6238 /* Otherwise just believe the CTE's rowcount estimate */
6240 }
6241
6242 /* Now estimate number of output rows, etc */
6244}
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:5492
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 6318 of file costsize.c.
6319{
6320 /* Should only be applied to base relations */
6322
6324
6326
6328}
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 6126 of file costsize.c.
6127{
6130
6131 /* Should only be applied to base relations that are functions */
6135
6136 /*
6137 * Estimate number of rows the functions will return. The rowcount of the
6138 * node is that of the largest function result.
6139 */
6140 rel->tuples = 0;
6142 {
6145
6148 }
6149
6150 /* Now estimate number of output rows, etc */
6152}
double expression_returns_set_rows(PlannerInfo *root, Node *clause)
Definition clauses.c:300
Definition parsenodes.h:1431
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 5571 of file costsize.c.
5576{
5578 rel,
5579 outer_rel,
5580 inner_rel,
5581 outer_rel->rows,
5582 inner_rel->rows,
5583 sjinfo,
5584 restrictlist);
5585}
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 6256 of file costsize.c.
6257{
6259
6260 /* Should only be applied to base relations that are tuplestore references */
6264
6265 /*
6266 * Use the estimate provided by the code which is generating the named
6267 * tuplestore. In some cases, the actual number might be available; in
6268 * others the same plan will be re-used, so a "typical" value might be
6269 * estimated and used.
6270 */
6273 rel->tuples = 1000;
6274
6275 /* Now estimate number of output rows, etc */
6277}
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 6510 of file costsize.c.
6511{
6514
6515 /* Vars are assumed to have cost zero, but other exprs do not */
6518
6520 {
6522
6524
6525 /* For non-Vars, account for evaluation cost */
6527 {
6528 QualCost cost;
6529
6533 }
6534 }
6535
6537
6538 return target;
6539}
static int32 get_expr_width(PlannerInfo *root, const Node *expr)
Definition costsize.c:6548
Definition primnodes.h:263
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 6289 of file costsize.c.
6290{
6291 /* Should only be applied to RTE_RESULT base relations */
6294
6295 /* RTE_RESULT always generates a single row, natively */
6296 rel->tuples = 1;
6297
6298 /* Now estimate number of output rows, etc */
6300}
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 6046 of file costsize.c.
6047{
6051
6052 /* Should only be applied to base relations that are subqueries */
6055
6056 /*
6057 * Copy raw number of output rows from subquery. All of its paths should
6058 * have the same output rowcount, so just look at cheapest-total.
6059 */
6062
6063 /*
6064 * Compute per-output-column width estimates by examining the subquery's
6065 * targetlist. For any output that is a plain Var, get the width estimate
6066 * that was made while planning the subquery. Otherwise, we leave it to
6067 * set_rel_width to fill in a datatype-based default estimate.
6068 */
6070 {
6074
6075 /* junk columns aren't visible to upper query */
6076 if (te->resjunk)
6077 continue;
6078
6079 /*
6080 * The subquery could be an expansion of a view that's had columns
6081 * added to it since the current query was parsed, so that there are
6082 * non-junk tlist columns in it that don't correspond to any column
6083 * visible at our query level. Ignore such columns.
6084 */
6086 continue;
6087
6088 /*
6089 * XXX This currently doesn't work for subqueries containing set
6090 * operations, because the Vars in their tlists are bogus references
6091 * to the first leaf subquery, which wouldn't give the right answer
6092 * even if we could still get to its PlannerInfo.
6093 *
6094 * Also, the subquery could be an appendrel for which all branches are
6095 * known empty due to constraint exclusion, in which case
6096 * set_append_rel_pathlist will have left the attr_widths set to zero.
6097 *
6098 * In either case, we just leave the width estimate zero until
6099 * set_rel_width fixes it.
6100 */
6103 {
6106
6108 }
6110 }
6111
6112 /* Now estimate number of output rows, etc */
6114}
RelOptInfo * fetch_upper_rel(PlannerInfo *root, UpperRelationKind kind, Relids relids)
Definition relnode.c:1617
Definition pathnodes.h:303
Definition primnodes.h:2262
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 6164 of file costsize.c.
6165{
6166 /* Should only be applied to base relations that are functions */
6169
6170 rel->tuples = 100;
6171
6172 /* Now estimate number of output rows, etc */
6174}
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 6186 of file costsize.c.
6187{
6189
6190 /* Should only be applied to base relations that are values lists */
6194
6195 /*
6196 * Estimate number of rows the values list will return. We know this
6197 * precisely based on the list length (well, barring set-returning
6198 * functions in list items, but that's a refinement not catered for
6199 * anywhere else either).
6200 */
6202
6203 /* Now estimate number of output rows, etc */
6205}
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 142 of file costsize.c.
Referenced by final_cost_hashjoin().
◆ enable_async_append
|
extern |
Definition at line 166 of file costsize.c.
Referenced by create_append_plan().
◆ enable_bitmapscan
|
extern |
Definition at line 149 of file costsize.c.
Referenced by standard_planner().
◆ enable_gathermerge
|
extern |
Definition at line 159 of file costsize.c.
Referenced by standard_planner().
◆ enable_hashagg
|
extern |
Definition at line 153 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 158 of file costsize.c.
Referenced by standard_planner().
◆ enable_incremental_sort
|
extern |
Definition at line 152 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 148 of file costsize.c.
Referenced by standard_planner().
◆ enable_indexscan
|
extern |
Definition at line 147 of file costsize.c.
Referenced by plan_cluster_use_sort(), and standard_planner().
◆ enable_material
|
extern |
Definition at line 155 of file costsize.c.
Referenced by build_subplan(), materialize_finished_plan(), and standard_planner().
◆ enable_memoize
|
extern |
Definition at line 156 of file costsize.c.
Referenced by standard_planner().
◆ enable_mergejoin
|
extern |
Definition at line 157 of file costsize.c.
Referenced by standard_planner().
◆ enable_nestloop
|
extern |
Definition at line 154 of file costsize.c.
Referenced by standard_planner().
◆ enable_parallel_append
|
extern |
Definition at line 162 of file costsize.c.
Referenced by add_paths_to_append_rel(), and generate_union_paths().
◆ enable_parallel_hash
|
extern |
Definition at line 163 of file costsize.c.
Referenced by hash_inner_and_outer().
◆ enable_partition_pruning
|
extern |
Definition at line 164 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 161 of file costsize.c.
Referenced by create_grouping_paths().
◆ enable_partitionwise_join
|
extern |
Definition at line 160 of file costsize.c.
Referenced by set_append_rel_size(), and standard_planner().
◆ enable_presorted_aggregate
|
extern |
Definition at line 165 of file costsize.c.
Referenced by adjust_group_pathkeys_for_groupagg().
◆ enable_seqscan
|
extern |
Definition at line 146 of file costsize.c.
Referenced by standard_planner().
◆ enable_sort
|
extern |
Definition at line 151 of file costsize.c.
Referenced by cost_sort(), and make_sort().
◆ enable_tidscan
|
extern |
Definition at line 150 of file costsize.c.
Referenced by standard_planner().
◆ max_parallel_workers_per_gather
|
extern |
Definition at line 144 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().
