Loading...
Searching...
No Matches
partprune.c File Reference
#include "postgres.h"#include "access/hash.h"#include "access/nbtree.h"#include "catalog/pg_operator.h"#include "catalog/pg_opfamily.h"#include "catalog/pg_proc.h"#include "catalog/pg_type.h"#include "executor/executor.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "optimizer/appendinfo.h"#include "optimizer/cost.h"#include "optimizer/optimizer.h"#include "optimizer/pathnode.h"#include "optimizer/placeholder.h"#include "parser/parsetree.h"#include "partitioning/partbounds.h"#include "partitioning/partprune.h"#include "utils/array.h"#include "utils/lsyscache.h"
Include dependency graph for partprune.c:
Go to the source code of this file.
Data Structures | |
| struct | PartClauseInfo |
| struct | GeneratePruningStepsContext |
| struct | PruneStepResult |
Macros | |
| #define | PartCollMatchesExprColl(partcoll, exprcoll) ((partcoll) == InvalidOid || (partcoll) == (exprcoll)) |
Macro Definition Documentation
◆ PartCollMatchesExprColl
| #define PartCollMatchesExprColl | ( | partcoll, | |
| exprcoll | |||
| ) | ((partcoll) == InvalidOid || (partcoll) == (exprcoll)) |
Definition at line 1784 of file partprune.c.
1831{
1836 Expr *expr;
1838
1839 /*
1840 * Recognize specially shaped clauses that match a Boolean partition key.
1841 */
1843 partkey, &expr,
1844 ¬clause);
1845
1847 {
1849
1850 /*
1851 * For bool tests in the form of partkey IS NOT true and IS NOT false,
1852 * we invert these clauses. Effectively, "partkey IS NOT true"
1853 * becomes "partkey IS false OR partkey IS NULL". We do this by
1854 * building an OR BoolExpr and forming a clause just like that and
1855 * punt it off to gen_partprune_steps_internal() to generate pruning
1856 * steps.
1857 */
1859 {
1864
1865 /* We expect 'notclause' to only be set to true for BooleanTests */
1867
1868 /* reverse the bool test */
1873 else
1874 {
1875 /*
1876 * We only expect match_boolean_partition_clause to return
1877 * PARTCLAUSE_MATCH_CLAUSE for IS_NOT_TRUE and IS_NOT_FALSE.
1878 */
1880 }
1881
1886 nulltest->location = -1;
1887
1890
1891 /* Finally, generate steps */
1893
1894 if (context->contradictory)
1899 }
1900
1903 /* Do pruning with the Boolean equality operator. */
1906 partclause->expr = expr;
1907 /* We know that expr is of Boolean type. */
1910
1912
1914 }
1916 {
1917 /*
1918 * Handle IS UNKNOWN and IS NOT UNKNOWN. These just logically
1919 * translate to IS NULL and IS NOT NULL.
1920 */
1923 }
1926 {
1929 *rightop;
1930 Oid opno,
1931 op_lefttype,
1932 op_righttype,
1934 Oid cmpfn;
1935 int op_strategy;
1938
1947 opno = opclause->opno;
1948
1949 /* check if the clause matches this partition key */
1951 expr = rightop;
1953 {
1954 /*
1955 * It's only useful if we can commute the operator to put the
1956 * partkey on the left. If we can't, the clause can be deemed
1957 * UNSUPPORTED. Even if its leftop matches some later partkey, we
1958 * now know it has Vars on the right, so it's no use.
1959 */
1960 opno = get_commutator(opno);
1963 expr = leftop;
1964 }
1965 else
1966 /* clause does not match this partition key, but perhaps next. */
1968
1969 /*
1970 * Partition key match also requires collation match. There may be
1971 * multiple partkeys with the same expression but different
1972 * collations, so failure is NOMATCH.
1973 */
1976
1977 /*
1978 * See if the operator is relevant to the partitioning opfamily.
1979 *
1980 * Normally we only care about operators that are listed as being part
1981 * of the partitioning operator family. But there is one exception:
1982 * the not-equals operators are not listed in any operator family
1983 * whatsoever, but their negators (equality) are. We can use one of
1984 * those if we find it, but only for list partitioning.
1985 *
1986 * Note: we report NOMATCH on failure if the negator isn't the
1987 * equality operator for the partkey's opfamily as other partkeys may
1988 * have the same expression but different opfamily. That's unlikely,
1989 * but not much more so than duplicate expressions with different
1990 * collations.
1991 */
1993 {
1995 &op_strategy, &op_lefttype,
1996 &op_righttype);
1997 }
1998 else
1999 {
2000 /* not supported for anything apart from LIST partitioned tables */
2003
2004 /* See if the negator is equality */
2007 {
2009 &op_strategy, &op_lefttype,
2010 &op_righttype);
2013 }
2014
2015 /* Nope, it's not <> either. */
2018 }
2019
2020 /*
2021 * Only allow strict operators. This will guarantee nulls are
2022 * filtered. (This test is likely useless, since btree and hash
2023 * comparison operators are generally strict.)
2024 */
2027
2028 /*
2029 * OK, we have a match to the partition key and a suitable operator.
2030 * Examine the other argument to see if it's usable for pruning.
2031 *
2032 * In most of these cases, we can return UNSUPPORTED because the same
2033 * failure would occur no matter which partkey it's matched to. (In
2034 * particular, now that we've successfully matched one side of the
2035 * opclause to a partkey, there is no chance that matching the other
2036 * side to another partkey will produce a usable result, since that'd
2037 * mean there are Vars on both sides.)
2038 *
2039 * Also, if we reject an argument for a target-dependent reason, set
2040 * appropriate fields of *context to report that. We postpone these
2041 * tests until after matching the partkey and the operator, so as to
2042 * reduce the odds of setting the context fields for clauses that do
2043 * not end up contributing to pruning steps.
2044 *
2045 * First, check for non-Const argument. (We assume that any immutable
2046 * subexpression will have been folded to a Const already.)
2047 */
2049 {
2050 Bitmapset *paramids;
2051
2052 /*
2053 * When pruning in the planner, we only support pruning using
2054 * comparisons to constants. We cannot prune on the basis of
2055 * anything that's not immutable. (Note that has_mutable_arg and
2056 * has_exec_param do not get set for this target value.)
2057 */
2060
2061 /*
2062 * We can never prune using an expression that contains Vars.
2063 */
2066
2067 /*
2068 * And we must reject anything containing a volatile function.
2069 * Stable functions are OK though.
2070 */
2073
2074 /*
2075 * See if there are any exec Params. If so, we can only use this
2076 * expression during per-scan pruning.
2077 */
2078 paramids = pull_exec_paramids(expr);
2080 {
2081 context->has_exec_param = true;
2084 }
2085 else
2086 {
2087 /* It's potentially usable, but mutable */
2088 context->has_mutable_arg = true;
2089 }
2090 }
2091
2092 /*
2093 * Check whether the comparison operator itself is immutable. (We
2094 * assume anything that's in a btree or hash opclass is at least
2095 * stable, but we need to check for immutability.)
2096 */
2098 {
2099 context->has_mutable_op = true;
2100
2101 /*
2102 * When pruning in the planner, we cannot prune with mutable
2103 * operators.
2104 */
2107 }
2108
2109 /*
2110 * Now find the procedure to use, based on the types. If the clause's
2111 * other argument is of the same type as the partitioning opclass's
2112 * declared input type, we can use the procedure cached in
2113 * PartitionKey. If not, search for a cross-type one in the same
2114 * opfamily; if one doesn't exist, report no match.
2115 */
2118 else
2119 {
2121 {
2122 /*
2123 * For range and list partitioning, we need the ordering
2124 * procedure with lefttype being the partition key's type,
2125 * and righttype the clause's operator's right type.
2126 */
2129 cmpfn =
2133 break;
2134
2135 /*
2136 * For hash partitioning, we need the hashing procedure
2137 * for the clause's type.
2138 */
2140 cmpfn =
2143 HASHEXTENDED_PROC);
2144 break;
2145
2146 default:
2148 part_scheme->strategy);
2150 break;
2151 }
2152
2155 }
2156
2157 /*
2158 * Build the clause, passing the negator if applicable.
2159 */
2163 {
2168 }
2169 else
2170 {
2171 partclause->opno = opno;
2173 partclause->op_strategy = op_strategy;
2174 }
2175 partclause->expr = expr;
2176 partclause->cmpfn = cmpfn;
2177
2179
2181 }
2183 {
2190 *elem_clauses;
2192
2196
2197 /* check if the LHS matches this partition key */
2201
2202 /*
2203 * See if the operator is relevant to the partitioning opfamily.
2204 *
2205 * In case of NOT IN (..), we get a '<>', which we handle if list
2206 * partitioning is in use and we're able to confirm that it's negator
2207 * is a btree equality operator belonging to the partitioning operator
2208 * family. As above, report NOMATCH for non-matching operator.
2209 */
2211 {
2213
2216
2219 {
2220 int strategy;
2221 Oid lefttype,
2222 righttype;
2223
2225 false, &strategy,
2226 &lefttype, &righttype);
2229 }
2230 else
2232 }
2233
2234 /*
2235 * Only allow strict operators. This will guarantee nulls are
2236 * filtered. (This test is likely useless, since btree and hash
2237 * comparison operators are generally strict.)
2238 */
2241
2242 /*
2243 * OK, we have a match to the partition key and a suitable operator.
2244 * Examine the array argument to see if it's usable for pruning. This
2245 * is identical to the logic for a plain OpExpr.
2246 */
2248 {
2249 Bitmapset *paramids;
2250
2251 /*
2252 * When pruning in the planner, we only support pruning using
2253 * comparisons to constants. We cannot prune on the basis of
2254 * anything that's not immutable. (Note that has_mutable_arg and
2255 * has_exec_param do not get set for this target value.)
2256 */
2259
2260 /*
2261 * We can never prune using an expression that contains Vars.
2262 */
2265
2266 /*
2267 * And we must reject anything containing a volatile function.
2268 * Stable functions are OK though.
2269 */
2272
2273 /*
2274 * See if there are any exec Params. If so, we can only use this
2275 * expression during per-scan pruning.
2276 */
2279 {
2280 context->has_exec_param = true;
2283 }
2284 else
2285 {
2286 /* It's potentially usable, but mutable */
2287 context->has_mutable_arg = true;
2288 }
2289 }
2290
2291 /*
2292 * Check whether the comparison operator itself is immutable. (We
2293 * assume anything that's in a btree or hash opclass is at least
2294 * stable, but we need to check for immutability.)
2295 */
2297 {
2298 context->has_mutable_op = true;
2299
2300 /*
2301 * When pruning in the planner, we cannot prune with mutable
2302 * operators.
2303 */
2306 }
2307
2308 /*
2309 * Examine the contents of the array argument.
2310 */
2313 {
2314 /*
2315 * For a constant array, convert the elements to a list of Const
2316 * nodes, one for each array element (excepting nulls).
2317 */
2321 bool elembyval;
2322 char elemalign;
2323 Datum *elem_values;
2324 bool *elem_nulls;
2325 int num_elems,
2326 i;
2327
2328 /* If the array itself is null, the saop returns null */
2329 if (arr->constisnull)
2331
2334 &elemlen, &elembyval, &elemalign);
2337 elemlen, elembyval, elemalign,
2338 &elem_values, &elem_nulls,
2339 &num_elems);
2341 {
2343
2344 /*
2345 * A null array element must lead to a null comparison result,
2346 * since saop_op is known strict. We can ignore it in the
2347 * useOr case, but otherwise it implies self-contradiction.
2348 */
2350 {
2352 continue;
2354 }
2355
2357 arr->constcollid, elemlen,
2360 }
2361 }
2363 {
2365
2366 /*
2367 * For a nested ArrayExpr, we don't know how to get the actual
2368 * scalar values out into a flat list, so we give up doing
2369 * anything with this ScalarArrayOpExpr.
2370 */
2373
2374 /*
2375 * Otherwise, we can just use the list of element values.
2376 */
2378 }
2379 else
2380 {
2381 /* Give up on any other clause types. */
2383 }
2384
2385 /*
2386 * Now generate a list of clauses, one for each array element, of the
2387 * form leftop saop_op elem_expr
2388 */
2391 {
2393
2398 }
2399
2400 /*
2401 * If we have an ANY clause and multiple elements, now turn the list
2402 * of clauses into an OR expression.
2403 */
2406
2407 /* Finally, generate steps */
2409 if (context->contradictory)
2414 }
2416 {
2419
2423
2424 /* Does arg match with this partition key column? */
2427
2429
2431 }
2432
2433 /*
2434 * If we get here then the return value depends on the result of the
2435 * match_boolean_partition_clause call above. If the call returned
2436 * PARTCLAUSE_UNSUPPORTED then we're either not dealing with a bool qual
2437 * or the bool qual is not suitable for pruning. Since the qual didn't
2438 * match up to any of the other qual types supported here, then trying to
2439 * match it against any other partition key is a waste of time, so just
2440 * return PARTCLAUSE_UNSUPPORTED. If the qual just couldn't be matched to
2441 * this partition key, then it may match another, so return
2442 * PARTCLAUSE_NOMATCH. The only other value that
2443 * match_boolean_partition_clause can return is PARTCLAUSE_MATCH_CLAUSE,
2444 * and since that value was already dealt with above, then we can just
2445 * return boolmatchstatus.
2446 */
2448}
2449
2450/*
2451 * get_steps_using_prefix
2452 * Generate a list of PartitionPruneStepOps based on the given input.
2453 *
2454 * 'step_lastexpr' and 'step_lastcmpfn' are the Expr and comparison function
2455 * belonging to the final partition key that we have a clause for. 'prefix'
2456 * is a list of PartClauseInfos for partition key numbers prior to the given
2457 * 'step_lastexpr' and 'step_lastcmpfn'. 'prefix' may contain multiple
2458 * PartClauseInfos belonging to a single partition key. We will generate a
2459 * PartitionPruneStepOp for each combination of the given PartClauseInfos
2460 * using, at most, one PartClauseInfo per partition key.
2461 *
2462 * For LIST and RANGE partitioned tables, callers must ensure that
2463 * step_nullkeys is NULL, and that prefix contains at least one clause for
2464 * each of the partition keys prior to the key that 'step_lastexpr' and
2465 * 'step_lastcmpfn' belong to.
2466 *
2467 * For HASH partitioned tables, callers must ensure that 'prefix' contains at
2468 * least one clause for each of the partition keys apart from the final key
2469 * (the expr and comparison function for the final key are in 'step_lastexpr'
2470 * and 'step_lastcmpfn'). A bit set in step_nullkeys can substitute clauses
2471 * in the 'prefix' list for any given key. If a bit is set in 'step_nullkeys'
2472 * for a given key, then there must be no PartClauseInfo for that key in the
2473 * 'prefix' list.
2474 *
2475 * For each of the above cases, callers must ensure that PartClauseInfos in
2476 * 'prefix' are sorted in ascending order of keyno.
2477 */
2485 List *prefix)
2486{
2487 /* step_nullkeys must be empty for RANGE and LIST partitioned tables */
2490
2491 /*
2492 * No recursive processing is required when 'prefix' is an empty list.
2493 * This occurs when there is only 1 partition key column.
2494 */
2496 {
2497 PartitionPruneStep *step;
2498
2499 step = gen_prune_step_op(context,
2500 step_opstrategy,
2501 step_op_is_ne,
2504 step_nullkeys);
2506 }
2507
2508 /* Recurse to generate steps for every combination of clauses. */
2510 step_opstrategy,
2511 step_op_is_ne,
2512 step_lastexpr,
2513 step_lastcmpfn,
2514 step_nullkeys,
2515 prefix,
2516 list_head(prefix),
2518}
2519
2520/*
2521 * get_steps_using_prefix_recurse
2522 * Generate and return a list of PartitionPruneStepOps using the 'prefix'
2523 * list of PartClauseInfos starting at the 'start' cell.
2524 *
2525 * When 'prefix' contains multiple PartClauseInfos for a single partition key
2526 * we create a PartitionPruneStepOp for each combination of duplicated
2527 * PartClauseInfos. The returned list will contain a PartitionPruneStepOp
2528 * for each unique combination of input PartClauseInfos containing at most one
2529 * PartClauseInfo per partition key.
2530 *
2531 * 'prefix' is the input list of PartClauseInfos sorted by keyno.
2532 * 'start' marks the cell that searching the 'prefix' list should start from.
2533 * 'step_exprs' and 'step_cmpfns' each contains the expressions and cmpfns
2534 * we've generated so far from the clauses for the previous part keys.
2535 */
2543 List *prefix,
2547{
2552
2553 /* Actually, recursion would be limited by PARTITION_MAX_KEYS. */
2554 check_stack_depth();
2555
2559
2560 /* Check if we need to recurse. */
2562 {
2565
2566 /*
2567 * Find the first PartClauseInfo belonging to the next partition key,
2568 * the next recursive call must start iteration of the prefix list
2569 * from that point.
2570 */
2572 {
2574
2576 break;
2577 }
2578
2579 /* record where to start iterating in the next recursive call */
2581
2582 /*
2583 * For each PartClauseInfo with keyno set to cur_keyno, add its expr
2584 * and cmpfn to step_exprs and step_cmpfns, respectively, and recurse
2585 * using 'next_start' as the starting point in the 'prefix' list.
2586 */
2588 {
2591 *step_cmpfns1;
2592
2595 {
2596 /* Leave the original step_exprs unmodified. */
2599
2600 /* Leave the original step_cmpfns unmodified. */
2603 }
2604 else
2605 {
2606 /* check the 'prefix' list is sorted correctly */
2608 break;
2609 }
2610
2612 step_opstrategy,
2613 step_op_is_ne,
2614 step_lastexpr,
2615 step_lastcmpfn,
2616 step_nullkeys,
2617 prefix,
2618 next_start,
2619 step_exprs1,
2620 step_cmpfns1);
2622
2625 }
2626 }
2627 else
2628 {
2629 /*
2630 * End the current recursion cycle and start generating steps, one for
2631 * each clause with cur_keyno, which is all clauses from here onward
2632 * till the end of the list. Note that for hash partitioning,
2633 * step_nullkeys is allowed to be non-empty, in which case step_exprs
2634 * would only contain expressions for the partition keys that are not
2635 * specified in step_nullkeys.
2636 */
2639
2640 /*
2641 * Note also that for hash partitioning, each partition key should
2642 * have either equality clauses or an IS NULL clause, so if a
2643 * partition key doesn't have an expression, it would be specified in
2644 * step_nullkeys.
2645 */
2647 != PARTITION_STRATEGY_HASH ||
2649 context->rel->part_scheme->partnatts);
2651 {
2653 PartitionPruneStep *step;
2655 *step_cmpfns1;
2656
2658
2659 /* Leave the original step_exprs unmodified. */
2663
2664 /* Leave the original step_cmpfns unmodified. */
2668
2669 step = gen_prune_step_op(context,
2672 step_nullkeys);
2674 }
2675 }
2676
2678}
2679
2680/*
2681 * get_matching_hash_bounds
2682 * Determine offset of the hash bound matching the specified values,
2683 * considering that all the non-null values come from clauses containing
2684 * a compatible hash equality operator and any keys that are null come
2685 * from an IS NULL clause.
2686 *
2687 * Generally this function will return a single matching bound offset,
2688 * although if a partition has not been setup for a given modulus then we may
2689 * return no matches. If the number of clauses found don't cover the entire
2690 * partition key, then we'll need to return all offsets.
2691 *
2692 * 'opstrategy' if non-zero must be HTEqualStrategyNumber.
2693 *
2694 * 'values' contains Datums indexed by the partition key to use for pruning.
2695 *
2696 * 'nvalues', the number of Datums in the 'values' array.
2697 *
2698 * 'partsupfunc' contains partition hashing functions that can produce correct
2699 * hash for the type of the values contained in 'values'.
2700 *
2701 * 'nullkeys' is the set of partition keys that are null.
2702 */
2707{
2717
2719
2720 /*
2721 * For hash partitioning we can only perform pruning based on equality
2722 * clauses to the partition key or IS NULL clauses. We also can only
2723 * prune if we got values for all keys.
2724 */
2726 {
2727 /*
2728 * If there are any values, they must have come from clauses
2729 * containing an equality operator compatible with hash partitioning.
2730 */
2732
2735
2737 values, isnull);
2738
2741 result->bound_offsets =
2743 }
2744 else
2745 {
2746 /* Report all valid offsets into the boundinfo->indexes array. */
2748 boundinfo->nindexes - 1);
2749 }
2750
2751 /*
2752 * There is neither a special hash null partition or the default hash
2753 * partition.
2754 */
2756
2758}
2759
2760/*
2761 * get_matching_list_bounds
2762 * Determine the offsets of list bounds matching the specified value,
2763 * according to the semantics of the given operator strategy
2764 *
2765 * scan_default will be set in the returned struct, if the default partition
2766 * needs to be scanned, provided one exists at all. scan_null will be set if
2767 * the special null-accepting partition needs to be scanned.
2768 *
2769 * 'opstrategy' if non-zero must be a btree strategy number.
2770 *
2771 * 'value' contains the value to use for pruning.
2772 *
2773 * 'nvalues', if non-zero, should be exactly 1, because of list partitioning.
2774 *
2775 * 'partsupfunc' contains the list partitioning comparison function to be used
2776 * to perform partition_list_bsearch
2777 *
2778 * 'nullkeys' is the set of partition keys that are null.
2779 */
2784{
2787 int off,
2788 minoff,
2789 maxoff;
2791 bool inclusive = false;
2793
2796
2798
2800 {
2801 /*
2802 * Nulls may exist in only one partition - the partition whose
2803 * accepted set of values includes null or the default partition if
2804 * the former doesn't exist.
2805 */
2808 else
2811 }
2812
2813 /*
2814 * If there are no datums to compare keys with, but there are partitions,
2815 * just return the default partition if one exists.
2816 */
2818 {
2821 }
2822
2823 minoff = 0;
2824 maxoff = boundinfo->ndatums - 1;
2825
2826 /*
2827 * If there are no values to compare with the datums in boundinfo, it
2828 * means the caller asked for partitions for all non-null datums. Add
2829 * indexes of *all* partitions, including the default if any.
2830 */
2831 if (nvalues == 0)
2832 {
2835 boundinfo->ndatums - 1);
2838 }
2839
2840 /* Special case handling of values coming from a <> operator clause. */
2842 {
2843 /*
2844 * First match to all bounds. We'll remove any matching datums below.
2845 */
2848 boundinfo->ndatums - 1);
2849
2850 off = partition_list_bsearch(partsupfunc, partcollation, boundinfo,
2853 {
2854
2855 /* We have a match. Remove from the result. */
2858 off);
2859 }
2860
2861 /* Always include the default partition if any. */
2863
2865 }
2866
2867 /*
2868 * With range queries, always include the default list partition, because
2869 * list partitions divide the key space in a discontinuous manner, not all
2870 * values in the given range will have a partition assigned. This may not
2871 * technically be true for some data types (e.g. integer types), however,
2872 * we currently lack any sort of infrastructure to provide us with proofs
2873 * that would allow us to do anything smarter here.
2874 */
2877
2878 switch (opstrategy)
2879 {
2881 off = partition_list_bsearch(partsupfunc,
2882 partcollation,
2883 boundinfo, value,
2884 &is_equal);
2886 {
2889 }
2890 else
2893
2895 inclusive = true;
2896 pg_fallthrough;
2898 off = partition_list_bsearch(partsupfunc,
2899 partcollation,
2900 boundinfo, value,
2901 &is_equal);
2902 if (off >= 0)
2903 {
2904 /* We don't want the matched datum to be in the result. */
2906 off++;
2907 }
2908 else
2909 {
2910 /*
2911 * This case means all partition bounds are greater, which in
2912 * turn means that all partitions satisfy this key.
2913 */
2914 off = 0;
2915 }
2916
2917 /*
2918 * off is greater than the numbers of datums we have partitions
2919 * for. The only possible partition that could contain a match is
2920 * the default partition, but we must've set context->scan_default
2921 * above anyway if one exists.
2922 */
2925
2926 minoff = off;
2927 break;
2928
2930 inclusive = true;
2931 pg_fallthrough;
2933 off = partition_list_bsearch(partsupfunc,
2934 partcollation,
2935 boundinfo, value,
2936 &is_equal);
2938 off--;
2939
2940 /*
2941 * off is smaller than the datums of all non-default partitions.
2942 * The only possible partition that could contain a match is the
2943 * default partition, but we must've set context->scan_default
2944 * above anyway if one exists.
2945 */
2946 if (off < 0)
2948
2949 maxoff = off;
2950 break;
2951
2952 default:
2954 break;
2955 }
2956
2957 Assert(minoff >= 0 && maxoff >= 0);
2960}
2961
2962
2963/*
2964 * get_matching_range_bounds
2965 * Determine the offsets of range bounds matching the specified values,
2966 * according to the semantics of the given operator strategy
2967 *
2968 * Each datum whose offset is in result is to be treated as the upper bound of
2969 * the partition that will contain the desired values.
2970 *
2971 * scan_default is set in the returned struct if a default partition exists
2972 * and we're absolutely certain that it needs to be scanned. We do *not* set
2973 * it just because values match portions of the key space uncovered by
2974 * partitions other than default (space which we normally assume to belong to
2975 * the default partition): the final set of bounds obtained after combining
2976 * multiple pruning steps might exclude it, so we infer its inclusion
2977 * elsewhere.
2978 *
2979 * 'opstrategy' must be a btree strategy number.
2980 *
2981 * 'values' contains Datums indexed by the partition key to use for pruning.
2982 *
2983 * 'nvalues', number of Datums in 'values' array. Must be <= context->partnatts.
2984 *
2985 * 'partsupfunc' contains the range partitioning comparison functions to be
2986 * used to perform partition_range_datum_bsearch or partition_rbound_datum_cmp
2987 * using.
2988 *
2989 * 'nullkeys' is the set of partition keys that are null.
2990 */
2995{
3001 int off,
3002 minoff,
3003 maxoff;
3005 bool inclusive = false;
3006
3008 Assert(nvalues <= partnatts);
3009
3011
3012 /*
3013 * If there are no datums to compare keys with, or if we got an IS NULL
3014 * clause just return the default partition, if it exists.
3015 */
3017 {
3020 }
3021
3022 minoff = 0;
3023 maxoff = boundinfo->ndatums;
3024
3025 /*
3026 * If there are no values to compare with the datums in boundinfo, it
3027 * means the caller asked for partitions for all non-null datums. Add
3028 * indexes of *all* partitions, including the default partition if one
3029 * exists.
3030 */
3031 if (nvalues == 0)
3032 {
3033 /* ignore key space not covered by any partitions */
3035 minoff++;
3037 maxoff--;
3038
3041 partindices[maxoff] >= 0);
3043
3045 }
3046
3047 /*
3048 * If the query does not constrain all key columns, we'll need to scan the
3049 * default partition, if any.
3050 */
3051 if (nvalues < partnatts)
3053
3054 switch (opstrategy)
3055 {
3057 /* Look for the smallest bound that is = lookup value. */
3058 off = partition_range_datum_bsearch(partsupfunc,
3059 partcollation,
3060 boundinfo,
3061 nvalues, values,
3062 &is_equal);
3063
3065 {
3066 if (nvalues == partnatts)
3067 {
3068 /* There can only be zero or one matching partition. */
3071 }
3072 else
3073 {
3075
3076 /*
3077 * Since the lookup value contains only a prefix of keys,
3078 * we must find other bounds that may also match the
3079 * prefix. partition_range_datum_bsearch() returns the
3080 * offset of one of them, find others by checking adjacent
3081 * bounds.
3082 */
3083
3084 /*
3085 * First find greatest bound that's smaller than the
3086 * lookup value.
3087 */
3088 while (off >= 1)
3089 {
3091
3092 cmpval =
3093 partition_rbound_datum_cmp(partsupfunc,
3094 partcollation,
3095 boundinfo->datums[off - 1],
3096 boundinfo->kind[off - 1],
3097 values, nvalues);
3099 break;
3100 off--;
3101 }
3102
3103 Assert(0 ==
3104 partition_rbound_datum_cmp(partsupfunc,
3105 partcollation,
3106 boundinfo->datums[off],
3107 boundinfo->kind[off],
3108 values, nvalues));
3109
3110 /*
3111 * We can treat 'off' as the offset of the smallest bound
3112 * to be included in the result, if we know it is the
3113 * upper bound of the partition in which the lookup value
3114 * could possibly exist. One case it couldn't is if the
3115 * bound, or precisely the matched portion of its prefix,
3116 * is not inclusive.
3117 */
3120 off++;
3121
3122 minoff = off;
3123
3124 /*
3125 * Now find smallest bound that's greater than the lookup
3126 * value.
3127 */
3128 off = saved_off;
3130 {
3132
3134 partcollation,
3135 boundinfo->datums[off + 1],
3136 boundinfo->kind[off + 1],
3137 values, nvalues);
3139 break;
3140 off++;
3141 }
3142
3143 Assert(0 ==
3144 partition_rbound_datum_cmp(partsupfunc,
3145 partcollation,
3146 boundinfo->datums[off],
3147 boundinfo->kind[off],
3148 values, nvalues));
3149
3150 /*
3151 * off + 1, then would be the offset of the greatest bound
3152 * to be included in the result.
3153 */
3154 maxoff = off + 1;
3155 }
3156
3157 Assert(minoff >= 0 && maxoff >= 0);
3159 }
3160 else
3161 {
3162 /*
3163 * The lookup value falls in the range between some bounds in
3164 * boundinfo. 'off' would be the offset of the greatest bound
3165 * that is <= lookup value, so add off + 1 to the result
3166 * instead as the offset of the upper bound of the only
3167 * partition that may contain the lookup value. If 'off' is
3168 * -1 indicating that all bounds are greater, then we simply
3169 * end up adding the first bound's offset, that is, 0.
3170 */
3172 }
3173
3175
3177 inclusive = true;
3178 pg_fallthrough;
3180
3181 /*
3182 * Look for the smallest bound that is > or >= lookup value and
3183 * set minoff to its offset.
3184 */
3185 off = partition_range_datum_bsearch(partsupfunc,
3186 partcollation,
3187 boundinfo,
3188 nvalues, values,
3189 &is_equal);
3190 if (off < 0)
3191 {
3192 /*
3193 * All bounds are greater than the lookup value, so include
3194 * all of them in the result.
3195 */
3196 minoff = 0;
3197 }
3198 else
3199 {
3201 {
3202 /*
3203 * Since the lookup value contains only a prefix of keys,
3204 * we must find other bounds that may also match the
3205 * prefix. partition_range_datum_bsearch() returns the
3206 * offset of one of them, find others by checking adjacent
3207 * bounds.
3208 *
3209 * Based on whether the lookup values are inclusive or
3210 * not, we must either include the indexes of all such
3211 * bounds in the result (that is, set minoff to the index
3212 * of smallest such bound) or find the smallest one that's
3213 * greater than the lookup values and set minoff to that.
3214 */
3216 {
3219
3220 nextoff = inclusive ? off - 1 : off + 1;
3221 cmpval =
3222 partition_rbound_datum_cmp(partsupfunc,
3223 partcollation,
3226 values, nvalues);
3228 break;
3229
3230 off = nextoff;
3231 }
3232
3233 Assert(0 ==
3234 partition_rbound_datum_cmp(partsupfunc,
3235 partcollation,
3236 boundinfo->datums[off],
3237 boundinfo->kind[off],
3238 values, nvalues));
3239
3240 minoff = inclusive ? off : off + 1;
3241 }
3242 else
3243 {
3244
3245 /*
3246 * lookup value falls in the range between some bounds in
3247 * boundinfo. off would be the offset of the greatest
3248 * bound that is <= lookup value, so add off + 1 to the
3249 * result instead as the offset of the upper bound of the
3250 * smallest partition that may contain the lookup value.
3251 */
3252 minoff = off + 1;
3253 }
3254 }
3255 break;
3256
3258 inclusive = true;
3259 pg_fallthrough;
3261
3262 /*
3263 * Look for the greatest bound that is < or <= lookup value and
3264 * set maxoff to its offset.
3265 */
3266 off = partition_range_datum_bsearch(partsupfunc,
3267 partcollation,
3268 boundinfo,
3269 nvalues, values,
3270 &is_equal);
3271 if (off >= 0)
3272 {
3273 /*
3274 * See the comment above.
3275 */
3277 {
3279 {
3282
3283 nextoff = inclusive ? off + 1 : off - 1;
3285 partcollation,
3288 values, nvalues);
3290 break;
3291
3292 off = nextoff;
3293 }
3294
3295 Assert(0 ==
3296 partition_rbound_datum_cmp(partsupfunc,
3297 partcollation,
3298 boundinfo->datums[off],
3299 boundinfo->kind[off],
3300 values, nvalues));
3301
3302 maxoff = inclusive ? off + 1 : off;
3303 }
3304
3305 /*
3306 * The lookup value falls in the range between some bounds in
3307 * boundinfo. 'off' would be the offset of the greatest bound
3308 * that is <= lookup value, so add off + 1 to the result
3309 * instead as the offset of the upper bound of the greatest
3310 * partition that may contain lookup value. If the lookup
3311 * value had exactly matched the bound, but it isn't
3312 * inclusive, no need add the adjacent partition.
3313 */
3315 maxoff = off + 1;
3316 else
3317 maxoff = off;
3318 }
3319 else
3320 {
3321 /*
3322 * 'off' is -1 indicating that all bounds are greater, so just
3323 * set the first bound's offset as maxoff.
3324 */
3325 maxoff = off + 1;
3326 }
3327 break;
3328
3329 default:
3331 break;
3332 }
3333
3336
3337 /*
3338 * If the smallest partition to return has MINVALUE (negative infinity) as
3339 * its lower bound, increment it to point to the next finite bound
3340 * (supposedly its upper bound), so that we don't inadvertently end up
3341 * scanning the default partition.
3342 */
3344 {
3346
3349 {
3350 minoff++;
3352 }
3353 }
3354
3355 /*
3356 * If the previous greatest partition has MAXVALUE (positive infinity) as
3357 * its upper bound (something only possible to do with multi-column range
3358 * partitioning), we scan switch to it as the greatest partition to
3359 * return. Again, so that we don't inadvertently end up scanning the
3360 * default partition.
3361 */
3363 {
3365
3368 {
3369 maxoff--;
3371 }
3372 }
3373
3374 Assert(minoff >= 0 && maxoff >= 0);
3375 if (minoff <= maxoff)
3377
3379}
3380
3381/*
3382 * pull_exec_paramids
3383 * Returns a Bitmapset containing the paramids of all Params with
3384 * paramkind = PARAM_EXEC in 'expr'.
3385 */
3388{
3390
3392
3394}
3395
3396static bool
3398{
3400 return false;
3402 {
3404
3407 return false;
3408 }
3410}
3411
3412/*
3413 * get_partkey_exec_paramids
3414 * Loop through given pruning steps and find out which exec Params
3415 * are used.
3416 *
3417 * Returns a Bitmapset of Param IDs.
3418 */
3421{
3424
3426 {
3429
3431 continue;
3432
3434 {
3436
3437 /* We can be quick for plain Consts */
3439 execparamids = bms_join(execparamids,
3440 pull_exec_paramids(expr));
3441 }
3442 }
3443
3444 return execparamids;
3445}
3446
3447/*
3448 * perform_pruning_base_step
3449 * Determines the indexes of datums that satisfy conditions specified in
3450 * 'opstep'.
3451 *
3452 * Result also contains whether special null-accepting and/or default
3453 * partition need to be scanned.
3454 */
3458{
3460 *lc2;
3461 int keyno,
3462 nvalues;
3464 FmgrInfo *partsupfunc;
3466
3467 /*
3468 * There better be the same number of expressions and compare functions.
3469 */
3471
3472 nvalues = 0;
3475
3476 /*
3477 * Generate the partition lookup key that will be used by one of the
3478 * get_matching_*_bounds functions called below.
3479 */
3481 {
3482 /*
3483 * For hash partitioning, it is possible that values of some keys are
3484 * not provided in operator clauses, but instead the planner found
3485 * that they appeared in a IS NULL clause.
3486 */
3488 continue;
3489
3490 /*
3491 * For range partitioning, we must only perform pruning with values
3492 * for either all partition keys or a prefix thereof.
3493 */
3495 break;
3496
3498 {
3499 Expr *expr;
3500 Datum datum;
3501 bool isnull;
3502 Oid cmpfn;
3503
3506 opstep->step.step_id, keyno);
3508 &datum, &isnull);
3509
3510 /*
3511 * Since we only allow strict operators in pruning steps, any
3512 * null-valued comparison value must cause the comparison to fail,
3513 * so that no partitions could match.
3514 */
3515 if (isnull)
3516 {
3518
3523
3525 }
3526
3527 /* Set up the stepcmpfuncs entry, unless we already did */
3531 {
3532 /*
3533 * If the needed support function is the same one cached in
3534 * the relation's partition key, copy the cached FmgrInfo.
3535 * Otherwise (i.e., when we have a cross-type comparison), an
3536 * actual lookup is required.
3537 */
3540 &context->partsupfunc[keyno],
3541 context->ppccontext);
3542 else
3544 context->ppccontext);
3545 }
3546
3547 values[keyno] = datum;
3548 nvalues++;
3549
3552 }
3553 }
3554
3555 /*
3556 * Point partsupfunc to the entry for the 0th key of this step; the
3557 * additional support functions, if any, follow consecutively.
3558 */
3561
3563 {
3566 opstep->opstrategy,
3567 values, nvalues,
3568 partsupfunc,
3569 opstep->nullkeys);
3570
3573 opstep->opstrategy,
3574 values[0], nvalues,
3575 &partsupfunc[0],
3576 opstep->nullkeys);
3577
3580 opstep->opstrategy,
3581 values, nvalues,
3582 partsupfunc,
3583 opstep->nullkeys);
3584
3585 default:
3588 break;
3589 }
3590
3592}
3593
3594/*
3595 * perform_pruning_combine_step
3596 * Determines the indexes of datums obtained by combining those given
3597 * by the steps identified by cstep->source_stepids using the specified
3598 * combination method
3599 *
3600 * Since cstep may refer to the result of earlier steps, we also receive
3601 * step_results here.
3602 */
3607{
3611
3612 /*
3613 * A combine step without any source steps is an indication to not perform
3614 * any partition pruning. Return all datum indexes in that case.
3615 */
3617 {
3619
3620 result->bound_offsets =
3625 }
3626
3628 {
3631 {
3634
3635 /*
3636 * step_results[step_id] must contain a valid result, which is
3637 * confirmed by the fact that cstep's step_id is greater than
3638 * step_id and the fact that results of the individual steps
3639 * are evaluated in sequence of their step_ids.
3640 */
3645
3646 /* Record any additional datum indexes from this step */
3648 step_result->bound_offsets);
3649
3650 /* Update whether to scan null and default partitions. */
3655 }
3656 break;
3657
3661 {
3664
3669
3671 {
3672 /* Copy step's result the first time. */
3673 result->bound_offsets =
3678 }
3679 else
3680 {
3681 /* Record datum indexes common to both steps */
3682 result->bound_offsets =
3684 step_result->bound_offsets);
3685
3686 /* Update whether to scan null and default partitions. */
3691 }
3692 }
3693 break;
3694 }
3695
3697}
3698
3699/*
3700 * match_boolean_partition_clause
3701 *
3702 * If we're able to match the clause to the partition key as specially-shaped
3703 * boolean clause, set *outconst to a Const containing a true, false or NULL
3704 * value, set *notclause according to if the clause was in the "not" form,
3705 * i.e. "IS NOT TRUE", "IS NOT FALSE" or "IS NOT UNKNOWN" and return
3706 * PARTCLAUSE_MATCH_CLAUSE for "IS [NOT] (TRUE|FALSE)" clauses and
3707 * PARTCLAUSE_MATCH_NULLNESS for "IS [NOT] UNKNOWN" clauses. Otherwise,
3708 * return PARTCLAUSE_UNSUPPORTED if the clause cannot be used for partition
3709 * pruning, and PARTCLAUSE_NOMATCH for supported clauses that do not match this
3710 * 'partkey'.
3711 */
3715{
3717
3720
3721 /*
3722 * Partitioning currently can only use built-in AMs, so checking for
3723 * built-in boolean opfamilies is good enough.
3724 */
3727
3729 {
3731
3736
3738 {
3740 {
3743 pg_fallthrough;
3749 pg_fallthrough;
3755 pg_fallthrough;
3758 default:
3760 }
3761 }
3762 /* does not match partition key */
3764 }
3765 else
3766 {
3768
3770
3774
3775 /* Compare to the partition key, and make up a clause ... */
3780 else
3782
3784 }
3785}
3786
3787/*
3788 * partkey_datum_from_expr
3789 * Evaluate expression for potential partition pruning
3790 *
3791 * Evaluate 'expr'; set *value and *isnull to the resulting Datum and nullflag.
3792 *
3793 * If expr isn't a Const, its ExprState is in stateidx of the context
3794 * exprstate array.
3795 *
3796 * Note that the evaluated result may be in the per-tuple memory context of
3797 * context->exprcontext, and we may have leaked other memory there too.
3798 * This memory must be recovered by resetting that ExprContext after
3799 * we're done with the pruning operation (see execPartition.c).
3800 */
3801static void
3805{
3807 {
3808 /* We can always determine the value of a constant */
3810
3811 *value = con->constvalue;
3812 *isnull = con->constisnull;
3813 }
3814 else
3815 {
3816 ExprState *exprstate;
3818
3819 /*
3820 * We should never see a non-Const in a step unless the caller has
3821 * passed a valid ExprContext.
3822 */
3824
3828 }
3829}
void deconstruct_array(const ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3638
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1093
Bitmapset * bms_add_range(Bitmapset *a, int lower, int upper)
Definition bitmapset.c:1003
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:901
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition executor.h:446
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition fmgr.c:139
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition fmgr.c:582
static struct @177 value
void get_op_opfamily_properties(Oid opno, Oid opfamily, bool ordering_op, int *strategy, Oid *lefttype, Oid *righttype)
Definition lsyscache.c:140
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition lsyscache.c:2464
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition lsyscache.c:915
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Definition makefuncs.c:420
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Definition makefuncs.c:701
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition makefuncs.c:350
int32 partition_rbound_datum_cmp(FmgrInfo *partsupfunc, Oid *partcollation, const Datum *rb_datums, PartitionRangeDatumKind *rb_kind, const Datum *tuple_datums, int n_tuple_datums)
Definition partbounds.c:3549
uint64 compute_partition_hash_value(int partnatts, FmgrInfo *partsupfunc, const Oid *partcollation, const Datum *values, const bool *isnull)
Definition partbounds.c:4715
int partition_range_datum_bsearch(FmgrInfo *partsupfunc, Oid *partcollation, PartitionBoundInfo boundinfo, int nvalues, const Datum *values, bool *is_equal)
Definition partbounds.c:3688
int partition_list_bsearch(FmgrInfo *partsupfunc, Oid *partcollation, PartitionBoundInfo boundinfo, Datum value, bool *is_equal)
Definition partbounds.c:3600
static PruneStepResult * get_matching_range_bounds(PartitionPruneContext *context, StrategyNumber opstrategy, const Datum *values, int nvalues, FmgrInfo *partsupfunc, Bitmapset *nullkeys)
Definition partprune.c:2993
static Bitmapset * get_partkey_exec_paramids(List *steps)
Definition partprune.c:3421
static PruneStepResult * get_matching_list_bounds(PartitionPruneContext *context, StrategyNumber opstrategy, Datum value, int nvalues, FmgrInfo *partsupfunc, Bitmapset *nullkeys)
Definition partprune.c:2782
static List * get_steps_using_prefix(GeneratePruningStepsContext *context, StrategyNumber step_opstrategy, bool step_op_is_ne, Expr *step_lastexpr, Oid step_lastcmpfn, Bitmapset *step_nullkeys, List *prefix)
Definition partprune.c:2480
static List * gen_partprune_steps_internal(GeneratePruningStepsContext *context, List *clauses)
Definition partprune.c:990
static PartClauseMatchStatus match_boolean_partition_clause(Oid partopfamily, Expr *clause, const Expr *partkey, Expr **outconst, bool *notclause)
Definition partprune.c:3714
static void partkey_datum_from_expr(PartitionPruneContext *context, Expr *expr, int stateidx, Datum *value, bool *isnull)
Definition partprune.c:3803
#define PartCollMatchesExprColl(partcoll, exprcoll)
Definition partprune.c:1784
static PruneStepResult * perform_pruning_base_step(PartitionPruneContext *context, PartitionPruneStepOp *opstep)
Definition partprune.c:3457
static PruneStepResult * perform_pruning_combine_step(PartitionPruneContext *context, PartitionPruneStepCombine *cstep, PruneStepResult **step_results)
Definition partprune.c:3605
static List * get_steps_using_prefix_recurse(GeneratePruningStepsContext *context, StrategyNumber step_opstrategy, bool step_op_is_ne, Expr *step_lastexpr, Oid step_lastcmpfn, Bitmapset *step_nullkeys, List *prefix, ListCell *start, List *step_exprs, List *step_cmpfns)
Definition partprune.c:2538
static PartitionPruneStep * gen_prune_step_op(GeneratePruningStepsContext *context, StrategyNumber opstrategy, bool op_is_ne, List *exprs, List *cmpfns, Bitmapset *nullkeys)
Definition partprune.c:1342
static PruneStepResult * get_matching_hash_bounds(PartitionPruneContext *context, StrategyNumber opstrategy, const Datum *values, int nvalues, FmgrInfo *partsupfunc, Bitmapset *nullkeys)
Definition partprune.c:2705
static bool pull_exec_paramids_walker(Node *node, Bitmapset **context)
Definition partprune.c:3398
Definition primnodes.h:1406
Definition array.h:93
Definition bitmapset.h:50
Definition primnodes.h:2008
Definition primnodes.h:325
Definition execnodes.h:282
Definition execnodes.h:99
Definition primnodes.h:190
Definition partprune.c:112
Definition pg_list.h:54
Definition nodes.h:135
Definition primnodes.h:1984
Definition primnodes.h:847
Definition primnodes.h:392
Definition partprune.c:64
Definition partbounds.h:80
Definition partprune.h:50
Definition plannodes.h:1800
Definition plannodes.h:1778
Definition plannodes.h:1743
Definition pathnodes.h:723
Definition partprune.c:129
Definition primnodes.h:1217
Definition primnodes.h:927
Definition pg_list.h:46
Typedef Documentation
◆ GeneratePruningStepsContext
◆ PartClauseInfo
| typedef struct PartClauseInfo PartClauseInfo |
◆ PartClauseMatchStatus
◆ PartClauseTarget
◆ PruneStepResult
Enumeration Type Documentation
◆ PartClauseMatchStatus
| Enumerator | |
|---|---|
| PARTCLAUSE_NOMATCH | |
| PARTCLAUSE_MATCH_CLAUSE | |
| PARTCLAUSE_MATCH_NULLNESS | |
| PARTCLAUSE_MATCH_STEPS | |
| PARTCLAUSE_MATCH_CONTRADICT | |
| PARTCLAUSE_UNSUPPORTED | |
Definition at line 78 of file partprune.c.
◆ PartClauseTarget
| Enumerator | |
|---|---|
| PARTTARGET_PLANNER | |
| PARTTARGET_INITIAL | |
| PARTTARGET_EXEC | |
Definition at line 92 of file partprune.c.
93{
97} PartClauseTarget;
Function Documentation
◆ add_part_relids()
Definition at line 400 of file partprune.c.
401{
404
405 /* We can easily get the lowest set bit this way: */
408
409 /* Look for a matching topmost parent */
411 {
414
416 {
417 /* Found a match, so add any new RT indexes to this hierarchy */
421 }
422 }
423 /* No match, so add the new partition hierarchy to the list */
425}
References Assert, bms_add_members(), bms_next_member(), fb(), lappend(), and lfirst.
Referenced by make_partition_pruneinfo().
◆ gen_partprune_steps()
|
static |
Definition at line 744 of file partprune.c.
746{
747 /* Initialize all output values to zero/false/NULL */
749 context->rel = rel;
750 context->target = target;
751
752 /*
753 * If this partitioned table is in turn a partition, and it shares any
754 * partition keys with its parent, then it's possible that the hierarchy
755 * allows the parent a narrower range of values than some of its
756 * partitions (particularly the default one). This is normally not
757 * useful, but it can be to prune the default partition.
758 */
760 {
761 /* Make a copy to avoid modifying the passed-in List */
763 }
764
765 /* Down into the rabbit-hole. */
767}
References fb(), gen_partprune_steps_internal(), list_concat_copy(), partition_bound_has_default, RelOptInfo::partition_qual, GeneratePruningStepsContext::rel, and GeneratePruningStepsContext::target.
Referenced by make_partitionedrel_pruneinfo(), and prune_append_rel_partitions().
◆ gen_partprune_steps_internal()
|
static |
Definition at line 990 of file partprune.c.
992{
1000
1001 /*
1002 * If this partitioned relation has a default partition and is itself a
1003 * partition (as evidenced by partition_qual being not NIL), we first
1004 * check if the clauses contradict the partition constraint. If they do,
1005 * there's no need to generate any steps as it'd already be proven that no
1006 * partitions need to be scanned.
1007 *
1008 * This is a measure of last resort only to be used because the default
1009 * partition cannot be pruned using the steps generated from clauses that
1010 * contradict the parent's partition constraint; regular pruning, which is
1011 * cheaper, is sufficient when no default partition exists.
1012 */
1015 {
1018 }
1019
1022 {
1025
1026 /* Look through RestrictInfo, if any */
1028 clause = ((RestrictInfo *) clause)->clause;
1029
1030 /* Constant-false-or-null is contradictory */
1032 (((Const *) clause)->constisnull ||
1034 {
1037 }
1038
1039 /* Get the BoolExpr's out of the way. */
1041 {
1042 /*
1043 * Generate steps for arguments.
1044 *
1045 * While steps generated for the arguments themselves will be
1046 * added to context->steps during recursion and will be evaluated
1047 * independently, collect their step IDs to be stored in the
1048 * combine step we'll be creating.
1049 */
1051 {
1055
1056 /*
1057 * We can share the outer context area with the recursive
1058 * call, but contradictory had better not be true yet.
1059 */
1061
1062 /*
1063 * Get pruning step for each arg. If we get contradictory for
1064 * all args, it means the OR expression is false as a whole.
1065 */
1067 {
1071
1075 /* Keep context->contradictory clear till we're done */
1077
1079 {
1080 /* Just ignore self-contradictory arguments. */
1081 continue;
1082 }
1083 else
1085
1087 {
1088 /*
1089 * gen_partprune_steps_internal() always adds a single
1090 * combine step when it generates multiple steps, so
1091 * here we can just pay attention to the last one in
1092 * the list. If it just generated one, then the last
1093 * one in the list is still the one we want.
1094 */
1096
1098 }
1099 else
1100 {
1102
1103 /*
1104 * The arg didn't contain a clause matching this
1105 * partition key. We cannot prune using such an arg.
1106 * To indicate that to the pruning code, we must
1107 * construct a dummy PartitionPruneStepCombine whose
1108 * source_stepids is set to an empty List.
1109 */
1111 PARTPRUNE_COMBINE_UNION);
1113 }
1114 }
1115
1116 /* If all the OR arms are contradictory, we can stop */
1118 {
1121 }
1122
1124 {
1125 PartitionPruneStep *step;
1126
1128 PARTPRUNE_COMBINE_UNION);
1130 }
1131 continue;
1132 }
1134 {
1137
1138 /*
1139 * args may itself contain clauses of arbitrary type, so just
1140 * recurse and later combine the component partitions sets
1141 * using a combine step.
1142 */
1144
1145 /* If any AND arm is contradictory, we can stop immediately */
1148
1149 /*
1150 * gen_partprune_steps_internal() always adds a single combine
1151 * step when it generates multiple steps, so here we can just
1152 * pay attention to the last one in the list. If it just
1153 * generated one, then the last one in the list is still the
1154 * one we want.
1155 */
1158
1159 continue;
1160 }
1161
1162 /*
1163 * Fall-through for a NOT clause, which if it's a Boolean clause,
1164 * will be handled in match_clause_to_partition_key(). We
1165 * currently don't perform any pruning for more complex NOT
1166 * clauses.
1167 */
1168 }
1169
1170 /*
1171 * See if we can match this clause to any of the partition keys.
1172 */
1174 {
1179
1182 &clause_is_not_null,
1184 {
1187
1188 /*
1189 * Since we only allow strict operators, check for any
1190 * contradicting IS NULL.
1191 */
1193 {
1196 }
1199 break;
1200
1203 {
1204 /*
1205 * check for conflicting IS NOT NULL as well as
1206 * contradicting strict clauses
1207 */
1210 {
1213 }
1215 }
1216 else
1217 {
1218 /* check for conflicting IS NULL */
1220 {
1223 }
1225 }
1226 break;
1227
1231 break;
1232
1234 /* We've nothing more to do if a contradiction was found. */
1237
1239
1240 /*
1241 * Clause didn't match this key, but it might match the
1242 * next one.
1243 */
1244 continue;
1245
1247 /* This clause cannot be used for pruning. */
1248 break;
1249 }
1250
1251 /* done; go check the next clause. */
1252 break;
1253 }
1254 }
1255
1256 /*-----------
1257 * Now generate some (more) pruning steps. We have three strategies:
1258 *
1259 * 1) Generate pruning steps based on IS NULL clauses:
1260 * a) For list partitioning, null partition keys can only be found in
1261 * the designated null-accepting partition, so if there are IS NULL
1262 * clauses containing partition keys we should generate a pruning
1263 * step that gets rid of all partitions but that one. We can
1264 * disregard any OpExpr we may have found.
1265 * b) For range partitioning, only the default partition can contain
1266 * NULL values, so the same rationale applies.
1267 * c) For hash partitioning, we only apply this strategy if we have
1268 * IS NULL clauses for all the keys. Strategy 2 below will take
1269 * care of the case where some keys have OpExprs and others have
1270 * IS NULL clauses.
1271 *
1272 * 2) If not, generate steps based on OpExprs we have (if any).
1273 *
1274 * 3) If this doesn't work either, we may be able to generate steps to
1275 * prune just the null-accepting partition (if one exists), if we have
1276 * IS NOT NULL clauses for all partition keys.
1277 */
1283 {
1284 PartitionPruneStep *step;
1285
1286 /* Strategy 1 */
1290 }
1292 {
1294
1295 /* Strategy 2 */
1298 }
1300 {
1301 PartitionPruneStep *step;
1302
1303 /* Strategy 3 */
1307 }
1308
1309 /*
1310 * Finally, if there are multiple steps, since the 'clauses' are mutually
1311 * ANDed, add an INTERSECT step to combine the partition sets resulting
1312 * from them and append it to the result list.
1313 */
1315 {
1318
1320 {
1322
1324 }
1325
1327 PARTPRUNE_COMBINE_INTERSECT);
1329 }
1330
1332}
static PartitionPruneStep * gen_prune_step_combine(GeneratePruningStepsContext *context, List *source_stepids, PartitionPruneCombineOp combineOp)
Definition partprune.c:1375
static PartClauseMatchStatus match_clause_to_partition_key(GeneratePruningStepsContext *context, Expr *clause, const Expr *partkey, int partkeyidx, bool *clause_is_not_null, PartClauseInfo **pc, List **clause_steps)
Definition partprune.c:1828
static List * gen_prune_steps_from_opexps(GeneratePruningStepsContext *context, List **keyclauses, Bitmapset *nullkeys)
Definition partprune.c:1412
bool predicate_refuted_by(List *predicate_list, List *clause_list, bool weak)
Definition predtest.c:224
Definition primnodes.h:968
Definition pathnodes.h:2895
References arg, Assert, bms_add_member(), bms_is_empty, bms_is_member(), bms_num_members(), GeneratePruningStepsContext::contradictory, DatumGetBool(), fb(), gen_partprune_steps_internal(), gen_prune_step_combine(), gen_prune_step_op(), gen_prune_steps_from_opexps(), i, InvalidStrategy, is_andclause(), is_orclause(), IsA, lappend(), lappend_int(), lfirst, linitial, list_concat(), list_length(), list_make1, llast, match_clause_to_partition_key(), NIL, PARTCLAUSE_MATCH_CLAUSE, PARTCLAUSE_MATCH_CONTRADICT, PARTCLAUSE_MATCH_NULLNESS, PARTCLAUSE_MATCH_STEPS, PARTCLAUSE_NOMATCH, PARTCLAUSE_UNSUPPORTED, partition_bound_has_default, PARTITION_MAX_KEYS, RelOptInfo::partition_qual, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, PARTPRUNE_COMBINE_INTERSECT, PARTPRUNE_COMBINE_UNION, predicate_refuted_by(), GeneratePruningStepsContext::rel, result, and PartitionPruneStep::step_id.
Referenced by gen_partprune_steps(), gen_partprune_steps_internal(), and match_clause_to_partition_key().
◆ gen_prune_step_combine()
|
static |
Definition at line 1375 of file partprune.c.
1378{
1380
1382 cstep->combineOp = combineOp;
1383 cstep->source_stepids = source_stepids;
1384
1386
1388}
References fb(), lappend(), makeNode, GeneratePruningStepsContext::next_step_id, and GeneratePruningStepsContext::steps.
Referenced by gen_partprune_steps_internal().
◆ gen_prune_step_op()
|
static |
Definition at line 1342 of file partprune.c.
1346{
1348
1350
1351 /*
1352 * For clauses that contain an <> operator, set opstrategy to
1353 * InvalidStrategy to signal get_matching_list_bounds to do the right
1354 * thing.
1355 */
1358 opstep->exprs = exprs;
1359 opstep->cmpfns = cmpfns;
1360 opstep->nullkeys = nullkeys;
1361
1363
1365}
References Assert, fb(), InvalidStrategy, lappend(), list_length(), makeNode, GeneratePruningStepsContext::next_step_id, and GeneratePruningStepsContext::steps.
Referenced by gen_partprune_steps_internal(), get_steps_using_prefix(), and get_steps_using_prefix_recurse().
◆ gen_prune_steps_from_opexps()
|
static |
Definition at line 1412 of file partprune.c.
1414{
1421
1425 {
1428
1429 /*
1430 * For range partitioning, if we have no clauses for the current key,
1431 * we can't consider any later keys either, so we can stop here.
1432 */
1435 break;
1436
1437 /*
1438 * For hash partitioning, if a column doesn't have the necessary
1439 * equality clause, there should be an IS NULL clause, otherwise
1440 * pruning is not possible.
1441 */
1445
1447 {
1449 Oid lefttype,
1450 righttype;
1451
1452 /* Look up the operator's btree/hash strategy number. */
1456 false,
1457 &pc->op_strategy,
1458 &lefttype,
1459 &righttype);
1460
1462 {
1467
1468 /*
1469 * We can't consider subsequent partition keys if the
1470 * clause for the current key contains a non-inclusive
1471 * operator.
1472 */
1476 break;
1477
1483 break;
1484
1485 default:
1487 part_scheme->strategy);
1488 break;
1489 }
1490 }
1491
1492 /*
1493 * If we've decided that clauses for subsequent partition keys
1494 * wouldn't be useful for pruning, don't search any further.
1495 */
1497 break;
1498 }
1499
1500 /*
1501 * Now, we have divided clauses according to their operator strategies.
1502 * Check for each strategy if we can generate pruning step(s) by
1503 * collecting a list of expressions whose values will constitute a vector
1504 * that can be used as a lookup key by a partition bound searching
1505 * function.
1506 */
1508 {
1511 {
1516
1517 /*
1518 * For each clause under consideration for a given strategy,
1519 * we collect expressions from clauses for earlier keys, whose
1520 * operator strategy is inclusive, into a list called
1521 * 'prefix'. By appending the clause's own expression to the
1522 * 'prefix', we'll generate one step using the so generated
1523 * vector and assign the current strategy to it. Actually,
1524 * 'prefix' might contain multiple clauses for the same key,
1525 * in which case, we must generate steps for various
1526 * combinations of expressions of different keys, which
1527 * get_steps_using_prefix takes care of for us.
1528 */
1530 {
1532 {
1542 int keyno;
1543
1544 /*
1545 * If this is a clause for the first partition key,
1546 * there are no preceding expressions; generate a
1547 * pruning step without a prefix.
1548 *
1549 * Note that we pass NULL for step_nullkeys, because
1550 * we don't search list/range partition bounds where
1551 * some keys are NULL.
1552 */
1554 {
1557 pc->op_is_ne,
1558 pc->expr,
1559 pc->cmpfn,
1560 NULL,
1561 NIL);
1563 continue;
1564 }
1565
1569
1570 /*
1571 * We arrange clauses into prefix in ascending order
1572 * of their partition key numbers.
1573 */
1575 {
1577
1578 /*
1579 * Expressions from = clauses can always be in the
1580 * prefix, provided they're from an earlier key.
1581 */
1583 {
1585
1587 {
1590 }
1591 else
1592 {
1594 break;
1595 }
1596 }
1598
1599 /*
1600 * If we're generating steps for </<= strategy, we
1601 * can add other <= clauses to the prefix,
1602 * provided they're from an earlier key.
1603 */
1606 {
1608 {
1610
1612 {
1615 }
1616 else
1617 {
1619 break;
1620 }
1621 }
1623 }
1624
1625 /*
1626 * If we're generating steps for >/>= strategy, we
1627 * can add other >= clauses to the prefix,
1628 * provided they're from an earlier key.
1629 */
1632 {
1634 {
1636
1638 {
1641 }
1642 else
1643 {
1645 break;
1646 }
1647 }
1649 }
1650
1651 /*
1652 * If this key has no clauses, prefix is not valid
1653 * anymore.
1654 */
1656 {
1658 break;
1659 }
1660 }
1661
1662 /*
1663 * If prefix_valid, generate PartitionPruneStepOps.
1664 * Otherwise, we would not find clauses for a valid
1665 * subset of the partition keys anymore for the
1666 * strategy; give up on generating partition pruning
1667 * steps further for the strategy.
1668 *
1669 * As mentioned above, if 'prefix' contains multiple
1670 * expressions for the same key, the following will
1671 * generate multiple steps, one for each combination
1672 * of the expressions for different keys.
1673 *
1674 * Note that we pass NULL for step_nullkeys, because
1675 * we don't search list/range partition bounds where
1676 * some keys are NULL.
1677 */
1679 {
1682 pc->op_is_ne,
1683 pc->expr,
1684 pc->cmpfn,
1685 NULL,
1686 prefix);
1688 }
1689 else
1690 break;
1691 }
1692 }
1693 break;
1694 }
1695
1697 {
1699
1700 /* For hash partitioning, we have just the = strategy. */
1702 {
1708
1709 /*
1710 * Locate the clause for the greatest column. This may
1711 * not belong to the last partition key, but it is the
1712 * clause belonging to the last partition key we found a
1713 * clause for above.
1714 */
1716
1717 /*
1718 * There might be multiple clauses which matched to that
1719 * partition key; find the first such clause. While at
1720 * it, add all the clauses before that one to 'prefix'.
1721 */
1724 {
1727 break;
1729 }
1730
1731 /*
1732 * For each clause for the "last" column, after appending
1733 * the clause's own expression to the 'prefix', we'll
1734 * generate one step using the so generated vector and
1735 * assign = as its strategy. Actually, 'prefix' might
1736 * contain multiple clauses for the same key, in which
1737 * case, we must generate steps for various combinations
1738 * of expressions of different keys, which
1739 * get_steps_using_prefix will take care of for us.
1740 */
1742 {
1744
1745 /*
1746 * Note that we pass nullkeys for step_nullkeys,
1747 * because we need to tell hash partition bound search
1748 * function which of the keys we found IS NULL clauses
1749 * for.
1750 */
1752 pc_steps =
1753 get_steps_using_prefix(context,
1754 HTEqualStrategyNumber,
1755 false,
1756 pc->expr,
1757 pc->cmpfn,
1758 nullkeys,
1759 prefix);
1761 }
1762 }
1763 break;
1764 }
1765
1766 default:
1768 part_scheme->strategy);
1769 break;
1770 }
1771
1773}
References Assert, bms_is_member(), BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTMaxStrategyNumber, elog, ERROR, fb(), for_each_cell, get_op_opfamily_properties(), get_steps_using_prefix(), HTEqualStrategyNumber, HTMaxStrategyNumber, i, InvalidStrategy, lappend(), lfirst, list_concat(), list_head(), llast, NIL, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and GeneratePruningStepsContext::rel.
Referenced by gen_partprune_steps_internal().
◆ get_matching_hash_bounds()
|
static |
Definition at line 2705 of file partprune.c.
2708{
2718
2720
2721 /*
2722 * For hash partitioning we can only perform pruning based on equality
2723 * clauses to the partition key or IS NULL clauses. We also can only
2724 * prune if we got values for all keys.
2725 */
2727 {
2728 /*
2729 * If there are any values, they must have come from clauses
2730 * containing an equality operator compatible with hash partitioning.
2731 */
2733
2736
2738 values, isnull);
2739
2742 result->bound_offsets =
2744 }
2745 else
2746 {
2747 /* Report all valid offsets into the boundinfo->indexes array. */
2749 boundinfo->nindexes - 1);
2750 }
2751
2752 /*
2753 * There is neither a special hash null partition or the default hash
2754 * partition.
2755 */
2757
2759}
References Assert, bms_add_range(), bms_is_member(), bms_make_singleton(), bms_num_members(), PartitionPruneContext::boundinfo, compute_partition_hash_value(), fb(), HTEqualStrategyNumber, i, PartitionBoundInfoData::indexes, PartitionBoundInfoData::nindexes, palloc0_object, PartitionPruneContext::partcollation, PARTITION_MAX_KEYS, PARTITION_STRATEGY_HASH, PartitionPruneContext::partnatts, result, PartitionPruneContext::strategy, and values.
Referenced by perform_pruning_base_step().
◆ get_matching_list_bounds()
|
static |
Definition at line 2782 of file partprune.c.
2785{
2788 int off,
2789 minoff,
2790 maxoff;
2792 bool inclusive = false;
2794
2797
2799
2801 {
2802 /*
2803 * Nulls may exist in only one partition - the partition whose
2804 * accepted set of values includes null or the default partition if
2805 * the former doesn't exist.
2806 */
2809 else
2812 }
2813
2814 /*
2815 * If there are no datums to compare keys with, but there are partitions,
2816 * just return the default partition if one exists.
2817 */
2819 {
2822 }
2823
2824 minoff = 0;
2825 maxoff = boundinfo->ndatums - 1;
2826
2827 /*
2828 * If there are no values to compare with the datums in boundinfo, it
2829 * means the caller asked for partitions for all non-null datums. Add
2830 * indexes of *all* partitions, including the default if any.
2831 */
2832 if (nvalues == 0)
2833 {
2836 boundinfo->ndatums - 1);
2839 }
2840
2841 /* Special case handling of values coming from a <> operator clause. */
2843 {
2844 /*
2845 * First match to all bounds. We'll remove any matching datums below.
2846 */
2849 boundinfo->ndatums - 1);
2850
2851 off = partition_list_bsearch(partsupfunc, partcollation, boundinfo,
2854 {
2855
2856 /* We have a match. Remove from the result. */
2859 off);
2860 }
2861
2862 /* Always include the default partition if any. */
2864
2866 }
2867
2868 /*
2869 * With range queries, always include the default list partition, because
2870 * list partitions divide the key space in a discontinuous manner, not all
2871 * values in the given range will have a partition assigned. This may not
2872 * technically be true for some data types (e.g. integer types), however,
2873 * we currently lack any sort of infrastructure to provide us with proofs
2874 * that would allow us to do anything smarter here.
2875 */
2878
2879 switch (opstrategy)
2880 {
2882 off = partition_list_bsearch(partsupfunc,
2883 partcollation,
2884 boundinfo, value,
2885 &is_equal);
2887 {
2890 }
2891 else
2894
2896 inclusive = true;
2897 pg_fallthrough;
2899 off = partition_list_bsearch(partsupfunc,
2900 partcollation,
2901 boundinfo, value,
2902 &is_equal);
2903 if (off >= 0)
2904 {
2905 /* We don't want the matched datum to be in the result. */
2907 off++;
2908 }
2909 else
2910 {
2911 /*
2912 * This case means all partition bounds are greater, which in
2913 * turn means that all partitions satisfy this key.
2914 */
2915 off = 0;
2916 }
2917
2918 /*
2919 * off is greater than the numbers of datums we have partitions
2920 * for. The only possible partition that could contain a match is
2921 * the default partition, but we must've set context->scan_default
2922 * above anyway if one exists.
2923 */
2926
2927 minoff = off;
2928 break;
2929
2931 inclusive = true;
2932 pg_fallthrough;
2934 off = partition_list_bsearch(partsupfunc,
2935 partcollation,
2936 boundinfo, value,
2937 &is_equal);
2939 off--;
2940
2941 /*
2942 * off is smaller than the datums of all non-default partitions.
2943 * The only possible partition that could contain a match is the
2944 * default partition, but we must've set context->scan_default
2945 * above anyway if one exists.
2946 */
2947 if (off < 0)
2949
2950 maxoff = off;
2951 break;
2952
2953 default:
2955 break;
2956 }
2957
2958 Assert(minoff >= 0 && maxoff >= 0);
2961}
References Assert, bms_add_range(), bms_del_member(), bms_is_empty, bms_make_singleton(), PartitionPruneContext::boundinfo, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, elog, ERROR, fb(), PartitionBoundInfoData::indexes, InvalidStrategy, PartitionBoundInfoData::ndatums, palloc0_object, PartitionPruneContext::partcollation, partition_bound_accepts_nulls, partition_bound_has_default, partition_list_bsearch(), PARTITION_STRATEGY_LIST, PartitionPruneContext::partnatts, pg_fallthrough, result, PartitionPruneContext::strategy, and value.
Referenced by perform_pruning_base_step().
◆ get_matching_partitions()
| Bitmapset * get_matching_partitions | ( | PartitionPruneContext * | context, |
| List * | pruning_steps | ||
| ) |
Definition at line 846 of file partprune.c.
847{
850 i;
851 PruneStepResult **results,
852 *final_result;
854 bool scan_default;
855
856 /* If there are no pruning steps then all partitions match. */
857 if (num_steps == 0)
858 {
861 }
862
863 /*
864 * Allocate space for individual pruning steps to store its result. Each
865 * slot will hold a PruneStepResult after performing a given pruning step.
866 * Later steps may use the result of one or more earlier steps. The
867 * result of applying all pruning steps is the value contained in the slot
868 * of the last pruning step.
869 */
870 results = (PruneStepResult **)
873 {
875
877 {
879 results[step->step_id] =
880 perform_pruning_base_step(context,
881 (PartitionPruneStepOp *) step);
882 break;
883
885 results[step->step_id] =
886 perform_pruning_combine_step(context,
887 (PartitionPruneStepCombine *) step,
888 results);
889 break;
890
891 default:
894 }
895 }
896
897 /*
898 * At this point we know the offsets of all the datums whose corresponding
899 * partitions need to be in the result, including special null-accepting
900 * and default partitions. Collect the actual partition indexes now.
901 */
902 final_result = results[num_steps - 1];
904 i = -1;
906 scan_default = final_result->scan_default;
908 {
910
913
915 {
916 /*
917 * In range partitioning cases, if a partition index is -1 it
918 * means that the bound at the offset is the upper bound for a
919 * range not covered by any partition (other than a possible
920 * default partition). In hash partitioning, the same means no
921 * partition has been defined for the corresponding remainder
922 * value.
923 *
924 * In either case, the value is still part of the queried range of
925 * values, so mark to scan the default partition if one exists.
926 */
928 continue;
929 }
930
932 }
933
934 /* Add the null and/or default partition if needed and present. */
936 {
940 }
941 if (scan_default)
942 {
947 }
948
950}
References Assert, bms_add_member(), bms_add_range(), bms_next_member(), PartitionPruneContext::boundinfo, PartitionBoundInfoData::default_index, elog, ERROR, fb(), i, PartitionBoundInfoData::indexes, lfirst, list_length(), nodeTag, PartitionPruneContext::nparts, PartitionBoundInfoData::null_index, palloc0(), partition_bound_accepts_nulls, partition_bound_has_default, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, perform_pruning_base_step(), perform_pruning_combine_step(), result, PartitionPruneStep::step_id, and PartitionPruneContext::strategy.
Referenced by find_matching_subplans_recurse(), and prune_append_rel_partitions().
◆ get_matching_range_bounds()
|
static |
Definition at line 2993 of file partprune.c.
2996{
3002 int off,
3003 minoff,
3004 maxoff;
3006 bool inclusive = false;
3007
3009 Assert(nvalues <= partnatts);
3010
3012
3013 /*
3014 * If there are no datums to compare keys with, or if we got an IS NULL
3015 * clause just return the default partition, if it exists.
3016 */
3018 {
3021 }
3022
3023 minoff = 0;
3024 maxoff = boundinfo->ndatums;
3025
3026 /*
3027 * If there are no values to compare with the datums in boundinfo, it
3028 * means the caller asked for partitions for all non-null datums. Add
3029 * indexes of *all* partitions, including the default partition if one
3030 * exists.
3031 */
3032 if (nvalues == 0)
3033 {
3034 /* ignore key space not covered by any partitions */
3036 minoff++;
3038 maxoff--;
3039
3042 partindices[maxoff] >= 0);
3044
3046 }
3047
3048 /*
3049 * If the query does not constrain all key columns, we'll need to scan the
3050 * default partition, if any.
3051 */
3052 if (nvalues < partnatts)
3054
3055 switch (opstrategy)
3056 {
3058 /* Look for the smallest bound that is = lookup value. */
3059 off = partition_range_datum_bsearch(partsupfunc,
3060 partcollation,
3061 boundinfo,
3062 nvalues, values,
3063 &is_equal);
3064
3066 {
3067 if (nvalues == partnatts)
3068 {
3069 /* There can only be zero or one matching partition. */
3072 }
3073 else
3074 {
3076
3077 /*
3078 * Since the lookup value contains only a prefix of keys,
3079 * we must find other bounds that may also match the
3080 * prefix. partition_range_datum_bsearch() returns the
3081 * offset of one of them, find others by checking adjacent
3082 * bounds.
3083 */
3084
3085 /*
3086 * First find greatest bound that's smaller than the
3087 * lookup value.
3088 */
3089 while (off >= 1)
3090 {
3092
3093 cmpval =
3094 partition_rbound_datum_cmp(partsupfunc,
3095 partcollation,
3096 boundinfo->datums[off - 1],
3097 boundinfo->kind[off - 1],
3098 values, nvalues);
3100 break;
3101 off--;
3102 }
3103
3104 Assert(0 ==
3105 partition_rbound_datum_cmp(partsupfunc,
3106 partcollation,
3107 boundinfo->datums[off],
3108 boundinfo->kind[off],
3109 values, nvalues));
3110
3111 /*
3112 * We can treat 'off' as the offset of the smallest bound
3113 * to be included in the result, if we know it is the
3114 * upper bound of the partition in which the lookup value
3115 * could possibly exist. One case it couldn't is if the
3116 * bound, or precisely the matched portion of its prefix,
3117 * is not inclusive.
3118 */
3121 off++;
3122
3123 minoff = off;
3124
3125 /*
3126 * Now find smallest bound that's greater than the lookup
3127 * value.
3128 */
3129 off = saved_off;
3131 {
3133
3135 partcollation,
3136 boundinfo->datums[off + 1],
3137 boundinfo->kind[off + 1],
3138 values, nvalues);
3140 break;
3141 off++;
3142 }
3143
3144 Assert(0 ==
3145 partition_rbound_datum_cmp(partsupfunc,
3146 partcollation,
3147 boundinfo->datums[off],
3148 boundinfo->kind[off],
3149 values, nvalues));
3150
3151 /*
3152 * off + 1, then would be the offset of the greatest bound
3153 * to be included in the result.
3154 */
3155 maxoff = off + 1;
3156 }
3157
3158 Assert(minoff >= 0 && maxoff >= 0);
3160 }
3161 else
3162 {
3163 /*
3164 * The lookup value falls in the range between some bounds in
3165 * boundinfo. 'off' would be the offset of the greatest bound
3166 * that is <= lookup value, so add off + 1 to the result
3167 * instead as the offset of the upper bound of the only
3168 * partition that may contain the lookup value. If 'off' is
3169 * -1 indicating that all bounds are greater, then we simply
3170 * end up adding the first bound's offset, that is, 0.
3171 */
3173 }
3174
3176
3178 inclusive = true;
3179 pg_fallthrough;
3181
3182 /*
3183 * Look for the smallest bound that is > or >= lookup value and
3184 * set minoff to its offset.
3185 */
3186 off = partition_range_datum_bsearch(partsupfunc,
3187 partcollation,
3188 boundinfo,
3189 nvalues, values,
3190 &is_equal);
3191 if (off < 0)
3192 {
3193 /*
3194 * All bounds are greater than the lookup value, so include
3195 * all of them in the result.
3196 */
3197 minoff = 0;
3198 }
3199 else
3200 {
3202 {
3203 /*
3204 * Since the lookup value contains only a prefix of keys,
3205 * we must find other bounds that may also match the
3206 * prefix. partition_range_datum_bsearch() returns the
3207 * offset of one of them, find others by checking adjacent
3208 * bounds.
3209 *
3210 * Based on whether the lookup values are inclusive or
3211 * not, we must either include the indexes of all such
3212 * bounds in the result (that is, set minoff to the index
3213 * of smallest such bound) or find the smallest one that's
3214 * greater than the lookup values and set minoff to that.
3215 */
3217 {
3220
3221 nextoff = inclusive ? off - 1 : off + 1;
3222 cmpval =
3223 partition_rbound_datum_cmp(partsupfunc,
3224 partcollation,
3227 values, nvalues);
3229 break;
3230
3231 off = nextoff;
3232 }
3233
3234 Assert(0 ==
3235 partition_rbound_datum_cmp(partsupfunc,
3236 partcollation,
3237 boundinfo->datums[off],
3238 boundinfo->kind[off],
3239 values, nvalues));
3240
3241 minoff = inclusive ? off : off + 1;
3242 }
3243 else
3244 {
3245
3246 /*
3247 * lookup value falls in the range between some bounds in
3248 * boundinfo. off would be the offset of the greatest
3249 * bound that is <= lookup value, so add off + 1 to the
3250 * result instead as the offset of the upper bound of the
3251 * smallest partition that may contain the lookup value.
3252 */
3253 minoff = off + 1;
3254 }
3255 }
3256 break;
3257
3259 inclusive = true;
3260 pg_fallthrough;
3262
3263 /*
3264 * Look for the greatest bound that is < or <= lookup value and
3265 * set maxoff to its offset.
3266 */
3267 off = partition_range_datum_bsearch(partsupfunc,
3268 partcollation,
3269 boundinfo,
3270 nvalues, values,
3271 &is_equal);
3272 if (off >= 0)
3273 {
3274 /*
3275 * See the comment above.
3276 */
3278 {
3280 {
3283
3284 nextoff = inclusive ? off + 1 : off - 1;
3286 partcollation,
3289 values, nvalues);
3291 break;
3292
3293 off = nextoff;
3294 }
3295
3296 Assert(0 ==
3297 partition_rbound_datum_cmp(partsupfunc,
3298 partcollation,
3299 boundinfo->datums[off],
3300 boundinfo->kind[off],
3301 values, nvalues));
3302
3303 maxoff = inclusive ? off + 1 : off;
3304 }
3305
3306 /*
3307 * The lookup value falls in the range between some bounds in
3308 * boundinfo. 'off' would be the offset of the greatest bound
3309 * that is <= lookup value, so add off + 1 to the result
3310 * instead as the offset of the upper bound of the greatest
3311 * partition that may contain lookup value. If the lookup
3312 * value had exactly matched the bound, but it isn't
3313 * inclusive, no need add the adjacent partition.
3314 */
3316 maxoff = off + 1;
3317 else
3318 maxoff = off;
3319 }
3320 else
3321 {
3322 /*
3323 * 'off' is -1 indicating that all bounds are greater, so just
3324 * set the first bound's offset as maxoff.
3325 */
3326 maxoff = off + 1;
3327 }
3328 break;
3329
3330 default:
3332 break;
3333 }
3334
3337
3338 /*
3339 * If the smallest partition to return has MINVALUE (negative infinity) as
3340 * its lower bound, increment it to point to the next finite bound
3341 * (supposedly its upper bound), so that we don't inadvertently end up
3342 * scanning the default partition.
3343 */
3345 {
3347
3350 {
3351 minoff++;
3353 }
3354 }
3355
3356 /*
3357 * If the previous greatest partition has MAXVALUE (positive infinity) as
3358 * its upper bound (something only possible to do with multi-column range
3359 * partitioning), we scan switch to it as the greatest partition to
3360 * return. Again, so that we don't inadvertently end up scanning the
3361 * default partition.
3362 */
3364 {
3366
3369 {
3370 maxoff--;
3372 }
3373 }
3374
3375 Assert(minoff >= 0 && maxoff >= 0);
3376 if (minoff <= maxoff)
3378
3380}
References Assert, bms_add_range(), bms_is_empty, bms_make_singleton(), PartitionPruneContext::boundinfo, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, PartitionBoundInfoData::datums, elog, ERROR, fb(), PartitionBoundInfoData::indexes, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, palloc0_object, PartitionPruneContext::partcollation, partition_bound_has_default, partition_range_datum_bsearch(), PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, partition_rbound_datum_cmp(), PARTITION_STRATEGY_RANGE, PartitionPruneContext::partnatts, pg_fallthrough, result, PartitionPruneContext::strategy, and values.
Referenced by perform_pruning_base_step().
◆ get_partkey_exec_paramids()
Definition at line 3421 of file partprune.c.
3422{
3425
3427 {
3430
3432 continue;
3433
3435 {
3437
3438 /* We can be quick for plain Consts */
3440 execparamids = bms_join(execparamids,
3441 pull_exec_paramids(expr));
3442 }
3443 }
3444
3445 return execparamids;
3446}
References bms_join(), PartitionPruneStepOp::exprs, fb(), IsA, lfirst, and pull_exec_paramids().
Referenced by make_partitionedrel_pruneinfo().
◆ get_steps_using_prefix()
|
static |
Definition at line 2480 of file partprune.c.
2487{
2488 /* step_nullkeys must be empty for RANGE and LIST partitioned tables */
2491
2492 /*
2493 * No recursive processing is required when 'prefix' is an empty list.
2494 * This occurs when there is only 1 partition key column.
2495 */
2497 {
2498 PartitionPruneStep *step;
2499
2500 step = gen_prune_step_op(context,
2501 step_opstrategy,
2502 step_op_is_ne,
2505 step_nullkeys);
2507 }
2508
2509 /* Recurse to generate steps for every combination of clauses. */
2511 step_opstrategy,
2512 step_op_is_ne,
2513 step_lastexpr,
2514 step_lastcmpfn,
2515 step_nullkeys,
2516 prefix,
2517 list_head(prefix),
2519}
References Assert, fb(), gen_prune_step_op(), get_steps_using_prefix_recurse(), list_head(), list_make1, list_make1_oid, NIL, PARTITION_STRATEGY_HASH, and GeneratePruningStepsContext::rel.
Referenced by gen_prune_steps_from_opexps().
◆ get_steps_using_prefix_recurse()
|
static |
Definition at line 2538 of file partprune.c.
2548{
2553
2554 /* Actually, recursion would be limited by PARTITION_MAX_KEYS. */
2555 check_stack_depth();
2556
2560
2561 /* Check if we need to recurse. */
2563 {
2566
2567 /*
2568 * Find the first PartClauseInfo belonging to the next partition key,
2569 * the next recursive call must start iteration of the prefix list
2570 * from that point.
2571 */
2573 {
2575
2577 break;
2578 }
2579
2580 /* record where to start iterating in the next recursive call */
2582
2583 /*
2584 * For each PartClauseInfo with keyno set to cur_keyno, add its expr
2585 * and cmpfn to step_exprs and step_cmpfns, respectively, and recurse
2586 * using 'next_start' as the starting point in the 'prefix' list.
2587 */
2589 {
2592 *step_cmpfns1;
2593
2596 {
2597 /* Leave the original step_exprs unmodified. */
2600
2601 /* Leave the original step_cmpfns unmodified. */
2604 }
2605 else
2606 {
2607 /* check the 'prefix' list is sorted correctly */
2609 break;
2610 }
2611
2613 step_opstrategy,
2614 step_op_is_ne,
2615 step_lastexpr,
2616 step_lastcmpfn,
2617 step_nullkeys,
2618 prefix,
2619 next_start,
2620 step_exprs1,
2621 step_cmpfns1);
2623
2626 }
2627 }
2628 else
2629 {
2630 /*
2631 * End the current recursion cycle and start generating steps, one for
2632 * each clause with cur_keyno, which is all clauses from here onward
2633 * till the end of the list. Note that for hash partitioning,
2634 * step_nullkeys is allowed to be non-empty, in which case step_exprs
2635 * would only contain expressions for the partition keys that are not
2636 * specified in step_nullkeys.
2637 */
2640
2641 /*
2642 * Note also that for hash partitioning, each partition key should
2643 * have either equality clauses or an IS NULL clause, so if a
2644 * partition key doesn't have an expression, it would be specified in
2645 * step_nullkeys.
2646 */
2648 != PARTITION_STRATEGY_HASH ||
2650 context->rel->part_scheme->partnatts);
2652 {
2654 PartitionPruneStep *step;
2656 *step_cmpfns1;
2657
2659
2660 /* Leave the original step_exprs unmodified. */
2664
2665 /* Leave the original step_cmpfns unmodified. */
2669
2670 step = gen_prune_step_op(context,
2673 step_nullkeys);
2675 }
2676 }
2677
2679}
References Assert, bms_is_empty, bms_num_members(), check_stack_depth(), fb(), for_each_cell, gen_prune_step_op(), get_steps_using_prefix_recurse(), lappend(), lappend_oid(), lfirst, list_concat(), list_copy(), list_free(), list_length(), llast, NIL, PARTITION_STRATEGY_HASH, GeneratePruningStepsContext::rel, result, and start.
Referenced by get_steps_using_prefix(), and get_steps_using_prefix_recurse().
◆ make_partition_pruneinfo()
| int make_partition_pruneinfo | ( | PlannerInfo * | root, |
| RelOptInfo * | parentrel, | ||
| List * | subpaths, | ||
| List * | prunequal | ||
| ) |
Definition at line 225 of file partprune.c.
228{
236
237 /*
238 * Scan the subpaths to see which ones are scans of partition child
239 * relations, and identify their parent partitioned rels. (Note: we must
240 * restrict the parent partitioned rels to be parentrel or children of
241 * parentrel, otherwise we couldn't translate prunequal to match.)
242 *
243 * Also construct a temporary array to map from partition-child-relation
244 * relid to the index in 'subpaths' of the scan plan for that partition.
245 * (Use of "subplan" rather than "subpath" is a bit of a misnomer, but
246 * we'll let it stand.) For convenience, we use 1-based indexes here, so
247 * that zero can represent an un-filled array entry.
248 */
251
252 i = 1;
254 {
257
258 /* We don't consider partitioned joins here */
260 {
263
264 /*
265 * Traverse up to the pathrel's topmost partitioned parent,
266 * collecting parent relids as we go; but stop if we reach
267 * parentrel. (Normally, a pathrel's topmost partitioned parent
268 * is either parentrel or a UNION ALL appendrel child of
269 * parentrel. But when handling partitionwise joins of
270 * multi-level partitioning trees, we can see an append path whose
271 * parentrel is an intermediate partitioned table.)
272 */
273 do
274 {
276
281 break; /* reached a non-partitioned parent */
282 /* accept this level as an interesting parent */
285 break; /* don't traverse above parentrel */
287
289 {
290 /*
291 * Found some relevant parent partitions, which may or may not
292 * overlap with partition trees we already found. Add new
293 * information to the allpartrelids list.
294 */
296 /* Also record the subplan in relid_subplan_map[] */
297 /* No duplicates please */
300 }
301 }
302 i++;
303 }
304
305 /*
306 * We now build a PartitionedRelPruneInfo for each topmost partitioned rel
307 * (omitting any that turn out not to have useful pruning quals).
308 */
311 {
315
317 prunequal,
318 partrelids,
319 relid_subplan_map,
320 &matchedsubplans);
321
322 /* When pruning is possible, record the matched subplans */
324 {
327 allmatchedsubplans);
328 }
329 }
330
332
333 /*
334 * If none of the partition hierarchies had any useful run-time pruning
335 * quals, then we can just not bother with run-time pruning.
336 */
338 return -1;
339
340 /* Else build the result data structure */
344
345 /*
346 * Some subplans may not belong to any of the identified partitioned rels.
347 * This can happen for UNION ALL queries which include a non-partitioned
348 * table, or when some of the hierarchies aren't run-time prunable. Build
349 * a bitmapset of the indexes of all such subplans, so that the executor
350 * can identify which subplans should never be pruned.
351 */
353 {
354 Bitmapset *other_subplans;
355
356 /* Create the complement of allmatchedsubplans */
359
360 pruneinfo->other_subplans = other_subplans;
361 }
362 else
364
366
368}
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1145
static List * add_part_relids(List *allpartrelids, Bitmapset *partrelids)
Definition partprune.c:400
static List * make_partitionedrel_pruneinfo(PlannerInfo *root, RelOptInfo *parentrel, List *prunequal, Bitmapset *partrelids, int *relid_subplan_map, Bitmapset **matchedsubplans)
Definition partprune.c:446
Definition pathnodes.h:3290
Definition plannodes.h:1664
Definition pathnodes.h:1965
Definition pathnodes.h:1010
References add_part_relids(), Assert, bms_add_member(), bms_add_range(), bms_copy(), bms_del_members(), bms_join(), bms_num_members(), fb(), find_base_rel(), i, IS_PARTITIONED_REL, lappend(), lfirst, list_length(), make_partitionedrel_pruneinfo(), makeNode, NIL, palloc0_array, pfree(), RELOPT_OTHER_MEMBER_REL, and root.
Referenced by create_append_plan(), and create_merge_append_plan().
◆ make_partitionedrel_pruneinfo()
|
static |
Definition at line 446 of file partprune.c.
451{
458 int rti;
460
461 /*
462 * Examine each partitioned rel, constructing a temporary array to map
463 * from planner relids to index of the partitioned rel, and building a
464 * PartitionedRelPruneInfo for each partitioned rel.
465 *
466 * In this phase we discover whether runtime pruning is needed at all; if
467 * not, we can avoid doing further work.
468 */
470
471 i = 1;
472 rti = -1;
474 {
476 PartitionedRelPruneInfo *pinfo;
478 List *initial_pruning_steps;
479 List *exec_pruning_steps;
480 Bitmapset *execparamids;
481 GeneratePruningStepsContext context;
482
483 /*
484 * Fill the mapping array.
485 *
486 * relid_subpart_map maps relid of a non-leaf partition to the index
487 * in the returned PartitionedRelPruneInfo list of the info for that
488 * partition. We use 1-based indexes here, so that zero can represent
489 * an un-filled array entry.
490 */
493
494 /*
495 * Translate pruning qual, if necessary, for this partition.
496 *
497 * The first item in the list is the target partitioned relation.
498 */
500 {
502
503 /*
504 * The prunequal is presented to us as a qual for 'parentrel'.
505 * Frequently this rel is the same as targetpart, so we can skip
506 * an adjust_appendrel_attrs step. But it might not be, and then
507 * we have to translate. We update the prunequal parameter here,
508 * because in later iterations of the loop for child partitions,
509 * we want to translate from parent to child variables.
510 */
512 {
513 int nappinfos;
515 subpart->relids,
516 &nappinfos);
517
519 prunequal,
520 nappinfos,
521 appinfos);
522
523 pfree(appinfos);
524 }
525
527 }
528 else
529 {
530 /*
531 * For sub-partitioned tables the columns may not be in the same
532 * order as the parent, so we must translate the prunequal to make
533 * it compatible with this relation.
534 */
538 subpart,
539 targetpart);
540 }
541
542 /*
543 * Convert pruning qual to pruning steps. We may need to do this
544 * twice, once to obtain executor startup pruning steps, and once for
545 * executor per-scan pruning steps. This first pass creates startup
546 * pruning steps and detects whether there's any possibly-useful quals
547 * that would require per-scan pruning.
548 */
550 &context);
551
553 {
554 /*
555 * This shouldn't happen as the planner should have detected this
556 * earlier. However, we do use additional quals from parameterized
557 * paths here. These do only compare Params to the partition key,
558 * so this shouldn't cause the discovery of any new qual
559 * contradictions that were not previously discovered as the Param
560 * values are unknown during planning. Anyway, we'd better do
561 * something sane here, so let's just disable run-time pruning.
562 */
564 }
565
566 /*
567 * If no mutable operators or expressions appear in usable pruning
568 * clauses, then there's no point in running startup pruning, because
569 * plan-time pruning should have pruned everything prunable.
570 */
572 initial_pruning_steps = context.steps;
573 else
574 initial_pruning_steps = NIL;
575
576 /*
577 * If no exec Params appear in potentially-usable pruning clauses,
578 * then there's no point in even thinking about per-scan pruning.
579 */
581 {
582 /* ... OK, we'd better think about it */
584 &context);
585
587 {
588 /* As above, skip run-time pruning if anything fishy happens */
590 }
591
592 exec_pruning_steps = context.steps;
593
594 /*
595 * Detect which exec Params actually got used; the fact that some
596 * were in available clauses doesn't mean we actually used them.
597 * Skip per-scan pruning if there are none.
598 */
599 execparamids = get_partkey_exec_paramids(exec_pruning_steps);
600
602 exec_pruning_steps = NIL;
603 }
604 else
605 {
606 /* No exec Params anywhere, so forget about scan-time pruning */
607 exec_pruning_steps = NIL;
608 execparamids = NULL;
609 }
610
611 if (initial_pruning_steps || exec_pruning_steps)
613
614 /* Begin constructing the PartitionedRelPruneInfo for this rel */
616 pinfo->rtindex = rti;
617 pinfo->initial_pruning_steps = initial_pruning_steps;
618 pinfo->exec_pruning_steps = exec_pruning_steps;
619 pinfo->execparamids = execparamids;
620 /* Remaining fields will be filled in the next loop */
621
623 }
624
626 {
627 /* No run-time pruning required. */
630 }
631
632 /*
633 * Run-time pruning will be required, so initialize other information.
634 * That includes two maps -- one needed to convert partition indexes of
635 * leaf partitions to the indexes of their subplans in the subplan list,
636 * another needed to convert partition indexes of sub-partitioned
637 * partitions to the indexes of their PartitionedRelPruneInfo in the
638 * PartitionedRelPruneInfo list.
639 */
641 {
644 Bitmapset *present_parts;
646 int *subplan_map;
647 int *subpart_map;
649 int *leafpart_rti_map;
650
651 /*
652 * Construct the subplan and subpart maps for this partitioning level.
653 * Here we convert to zero-based indexes, with -1 for empty entries.
654 * Also construct a Bitmapset of all partitions that are present (that
655 * is, not pruned already).
656 */
663 present_parts = NULL;
664
665 i = -1;
667 {
671
673
677
678 /*
679 * Track the RT indexes of "leaf" partitions so they can be
680 * included in the PlannerGlobal.prunableRelids set, indicating
681 * relations that may be pruned during executor startup.
682 *
683 * Only leaf partitions with a valid subplan that are prunable
684 * using initial pruning are added to prunableRelids. So
685 * partitions without a subplan due to constraint exclusion will
686 * remain in PlannedStmt.unprunableRelids.
687 */
689 {
691
692 /*
693 * Non-leaf partitions may appear here when they use an
694 * unflattened Append or MergeAppend. These should not be
695 * included in prunableRelids.
696 */
699
700 /* Record finding this subplan */
702 }
705 }
706
707 /*
708 * Ensure there were no stray PartitionedRelPruneInfo generated for
709 * partitioned tables that we have no sub-paths or
710 * sub-PartitionedRelPruneInfo for.
711 */
713
714 /* Record the maps and other information. */
715 pinfo->present_parts = present_parts;
716 pinfo->nparts = nparts;
717 pinfo->subplan_map = subplan_map;
718 pinfo->subpart_map = subpart_map;
719 pinfo->relid_map = relid_map;
720 pinfo->leafpart_rti_map = leafpart_rti_map;
721 }
722
724
726
728}
AppendRelInfo ** find_appinfos_by_relids(PlannerInfo *root, Relids relids, int *nappinfos)
Definition appendinfo.c:809
Node * adjust_appendrel_attrs(PlannerInfo *root, Node *node, int nappinfos, AppendRelInfo **appinfos)
Definition appendinfo.c:201
Node * adjust_appendrel_attrs_multilevel(PlannerInfo *root, Node *node, RelOptInfo *childrel, RelOptInfo *parentrel)
Definition appendinfo.c:597
static void gen_partprune_steps(RelOptInfo *rel, List *clauses, PartClauseTarget target, GeneratePruningStepsContext *context)
Definition partprune.c:744
Definition plannodes.h:1695
List * initial_pruning_steps
Definition plannodes.h:1728
References adjust_appendrel_attrs(), adjust_appendrel_attrs_multilevel(), Assert, bms_add_member(), bms_equal(), bms_is_empty, bms_next_member(), GeneratePruningStepsContext::contradictory, PartitionedRelPruneInfo::exec_pruning_steps, PartitionedRelPruneInfo::execparamids, fb(), find_appinfos_by_relids(), find_base_rel(), gen_partprune_steps(), get_partkey_exec_paramids(), GeneratePruningStepsContext::has_exec_param, GeneratePruningStepsContext::has_mutable_arg, GeneratePruningStepsContext::has_mutable_op, i, PartitionedRelPruneInfo::initial_pruning_steps, lappend(), lfirst, makeNode, NIL, RelOptInfo::nparts, PartitionedRelPruneInfo::nparts, palloc(), palloc0(), palloc0_array, PARTTARGET_EXEC, PARTTARGET_INITIAL, pfree(), planner_rt_fetch, PartitionedRelPruneInfo::present_parts, RelOptInfo::relid, root, PartitionedRelPruneInfo::rtindex, and GeneratePruningStepsContext::steps.
Referenced by make_partition_pruneinfo().
◆ match_boolean_partition_clause()
|
static |
Definition at line 3714 of file partprune.c.
3716{
3718
3721
3722 /*
3723 * Partitioning currently can only use built-in AMs, so checking for
3724 * built-in boolean opfamilies is good enough.
3725 */
3728
3730 {
3732
3737
3739 {
3741 {
3744 pg_fallthrough;
3750 pg_fallthrough;
3756 pg_fallthrough;
3759 default:
3761 }
3762 }
3763 /* does not match partition key */
3765 }
3766 else
3767 {
3769
3771
3775
3776 /* Compare to the partition key, and make up a clause ... */
3781 else
3783
3785 }
3786}
References arg, equal(), fb(), get_notclausearg(), IS_FALSE, IS_NOT_FALSE, IS_NOT_TRUE, IS_NOT_UNKNOWN, is_notclause(), IS_TRUE, IS_UNKNOWN, IsA, makeBoolConst(), negate_clause(), PARTCLAUSE_MATCH_CLAUSE, PARTCLAUSE_MATCH_NULLNESS, PARTCLAUSE_NOMATCH, PARTCLAUSE_UNSUPPORTED, pg_fallthrough, and strip_noop_phvs().
Referenced by match_clause_to_partition_key().
◆ match_clause_to_partition_key()
|
static |
Definition at line 1828 of file partprune.c.
1832{
1837 Expr *expr;
1839
1840 /*
1841 * Recognize specially shaped clauses that match a Boolean partition key.
1842 */
1844 partkey, &expr,
1845 ¬clause);
1846
1848 {
1850
1851 /*
1852 * For bool tests in the form of partkey IS NOT true and IS NOT false,
1853 * we invert these clauses. Effectively, "partkey IS NOT true"
1854 * becomes "partkey IS false OR partkey IS NULL". We do this by
1855 * building an OR BoolExpr and forming a clause just like that and
1856 * punt it off to gen_partprune_steps_internal() to generate pruning
1857 * steps.
1858 */
1860 {
1865
1866 /* We expect 'notclause' to only be set to true for BooleanTests */
1868
1869 /* reverse the bool test */
1874 else
1875 {
1876 /*
1877 * We only expect match_boolean_partition_clause to return
1878 * PARTCLAUSE_MATCH_CLAUSE for IS_NOT_TRUE and IS_NOT_FALSE.
1879 */
1881 }
1882
1887 nulltest->location = -1;
1888
1891
1892 /* Finally, generate steps */
1894
1900 }
1901
1904 /* Do pruning with the Boolean equality operator. */
1907 partclause->expr = expr;
1908 /* We know that expr is of Boolean type. */
1911
1913
1915 }
1917 {
1918 /*
1919 * Handle IS UNKNOWN and IS NOT UNKNOWN. These just logically
1920 * translate to IS NULL and IS NOT NULL.
1921 */
1924 }
1927 {
1930 *rightop;
1931 Oid opno,
1932 op_lefttype,
1933 op_righttype,
1935 Oid cmpfn;
1936 int op_strategy;
1939
1948 opno = opclause->opno;
1949
1950 /* check if the clause matches this partition key */
1952 expr = rightop;
1954 {
1955 /*
1956 * It's only useful if we can commute the operator to put the
1957 * partkey on the left. If we can't, the clause can be deemed
1958 * UNSUPPORTED. Even if its leftop matches some later partkey, we
1959 * now know it has Vars on the right, so it's no use.
1960 */
1961 opno = get_commutator(opno);
1964 expr = leftop;
1965 }
1966 else
1967 /* clause does not match this partition key, but perhaps next. */
1969
1970 /*
1971 * Partition key match also requires collation match. There may be
1972 * multiple partkeys with the same expression but different
1973 * collations, so failure is NOMATCH.
1974 */
1977
1978 /*
1979 * See if the operator is relevant to the partitioning opfamily.
1980 *
1981 * Normally we only care about operators that are listed as being part
1982 * of the partitioning operator family. But there is one exception:
1983 * the not-equals operators are not listed in any operator family
1984 * whatsoever, but their negators (equality) are. We can use one of
1985 * those if we find it, but only for list partitioning.
1986 *
1987 * Note: we report NOMATCH on failure if the negator isn't the
1988 * equality operator for the partkey's opfamily as other partkeys may
1989 * have the same expression but different opfamily. That's unlikely,
1990 * but not much more so than duplicate expressions with different
1991 * collations.
1992 */
1994 {
1996 &op_strategy, &op_lefttype,
1997 &op_righttype);
1998 }
1999 else
2000 {
2001 /* not supported for anything apart from LIST partitioned tables */
2004
2005 /* See if the negator is equality */
2008 {
2010 &op_strategy, &op_lefttype,
2011 &op_righttype);
2014 }
2015
2016 /* Nope, it's not <> either. */
2019 }
2020
2021 /*
2022 * Only allow strict operators. This will guarantee nulls are
2023 * filtered. (This test is likely useless, since btree and hash
2024 * comparison operators are generally strict.)
2025 */
2028
2029 /*
2030 * OK, we have a match to the partition key and a suitable operator.
2031 * Examine the other argument to see if it's usable for pruning.
2032 *
2033 * In most of these cases, we can return UNSUPPORTED because the same
2034 * failure would occur no matter which partkey it's matched to. (In
2035 * particular, now that we've successfully matched one side of the
2036 * opclause to a partkey, there is no chance that matching the other
2037 * side to another partkey will produce a usable result, since that'd
2038 * mean there are Vars on both sides.)
2039 *
2040 * Also, if we reject an argument for a target-dependent reason, set
2041 * appropriate fields of *context to report that. We postpone these
2042 * tests until after matching the partkey and the operator, so as to
2043 * reduce the odds of setting the context fields for clauses that do
2044 * not end up contributing to pruning steps.
2045 *
2046 * First, check for non-Const argument. (We assume that any immutable
2047 * subexpression will have been folded to a Const already.)
2048 */
2050 {
2051 Bitmapset *paramids;
2052
2053 /*
2054 * When pruning in the planner, we only support pruning using
2055 * comparisons to constants. We cannot prune on the basis of
2056 * anything that's not immutable. (Note that has_mutable_arg and
2057 * has_exec_param do not get set for this target value.)
2058 */
2061
2062 /*
2063 * We can never prune using an expression that contains Vars.
2064 */
2067
2068 /*
2069 * And we must reject anything containing a volatile function.
2070 * Stable functions are OK though.
2071 */
2074
2075 /*
2076 * See if there are any exec Params. If so, we can only use this
2077 * expression during per-scan pruning.
2078 */
2079 paramids = pull_exec_paramids(expr);
2081 {
2085 }
2086 else
2087 {
2088 /* It's potentially usable, but mutable */
2090 }
2091 }
2092
2093 /*
2094 * Check whether the comparison operator itself is immutable. (We
2095 * assume anything that's in a btree or hash opclass is at least
2096 * stable, but we need to check for immutability.)
2097 */
2099 {
2101
2102 /*
2103 * When pruning in the planner, we cannot prune with mutable
2104 * operators.
2105 */
2108 }
2109
2110 /*
2111 * Now find the procedure to use, based on the types. If the clause's
2112 * other argument is of the same type as the partitioning opclass's
2113 * declared input type, we can use the procedure cached in
2114 * PartitionKey. If not, search for a cross-type one in the same
2115 * opfamily; if one doesn't exist, report no match.
2116 */
2119 else
2120 {
2122 {
2123 /*
2124 * For range and list partitioning, we need the ordering
2125 * procedure with lefttype being the partition key's type,
2126 * and righttype the clause's operator's right type.
2127 */
2130 cmpfn =
2134 break;
2135
2136 /*
2137 * For hash partitioning, we need the hashing procedure
2138 * for the clause's type.
2139 */
2141 cmpfn =
2144 HASHEXTENDED_PROC);
2145 break;
2146
2147 default:
2149 part_scheme->strategy);
2151 break;
2152 }
2153
2156 }
2157
2158 /*
2159 * Build the clause, passing the negator if applicable.
2160 */
2164 {
2169 }
2170 else
2171 {
2172 partclause->opno = opno;
2174 partclause->op_strategy = op_strategy;
2175 }
2176 partclause->expr = expr;
2177 partclause->cmpfn = cmpfn;
2178
2180
2182 }
2184 {
2191 *elem_clauses;
2193
2197
2198 /* check if the LHS matches this partition key */
2202
2203 /*
2204 * See if the operator is relevant to the partitioning opfamily.
2205 *
2206 * In case of NOT IN (..), we get a '<>', which we handle if list
2207 * partitioning is in use and we're able to confirm that it's negator
2208 * is a btree equality operator belonging to the partitioning operator
2209 * family. As above, report NOMATCH for non-matching operator.
2210 */
2212 {
2214
2217
2220 {
2221 int strategy;
2222 Oid lefttype,
2223 righttype;
2224
2226 false, &strategy,
2227 &lefttype, &righttype);
2230 }
2231 else
2233 }
2234
2235 /*
2236 * Only allow strict operators. This will guarantee nulls are
2237 * filtered. (This test is likely useless, since btree and hash
2238 * comparison operators are generally strict.)
2239 */
2242
2243 /*
2244 * OK, we have a match to the partition key and a suitable operator.
2245 * Examine the array argument to see if it's usable for pruning. This
2246 * is identical to the logic for a plain OpExpr.
2247 */
2249 {
2250 Bitmapset *paramids;
2251
2252 /*
2253 * When pruning in the planner, we only support pruning using
2254 * comparisons to constants. We cannot prune on the basis of
2255 * anything that's not immutable. (Note that has_mutable_arg and
2256 * has_exec_param do not get set for this target value.)
2257 */
2260
2261 /*
2262 * We can never prune using an expression that contains Vars.
2263 */
2266
2267 /*
2268 * And we must reject anything containing a volatile function.
2269 * Stable functions are OK though.
2270 */
2273
2274 /*
2275 * See if there are any exec Params. If so, we can only use this
2276 * expression during per-scan pruning.
2277 */
2280 {
2284 }
2285 else
2286 {
2287 /* It's potentially usable, but mutable */
2289 }
2290 }
2291
2292 /*
2293 * Check whether the comparison operator itself is immutable. (We
2294 * assume anything that's in a btree or hash opclass is at least
2295 * stable, but we need to check for immutability.)
2296 */
2298 {
2300
2301 /*
2302 * When pruning in the planner, we cannot prune with mutable
2303 * operators.
2304 */
2307 }
2308
2309 /*
2310 * Examine the contents of the array argument.
2311 */
2314 {
2315 /*
2316 * For a constant array, convert the elements to a list of Const
2317 * nodes, one for each array element (excepting nulls).
2318 */
2322 bool elembyval;
2323 char elemalign;
2324 Datum *elem_values;
2325 bool *elem_nulls;
2326 int num_elems,
2327 i;
2328
2329 /* If the array itself is null, the saop returns null */
2330 if (arr->constisnull)
2332
2335 &elemlen, &elembyval, &elemalign);
2338 elemlen, elembyval, elemalign,
2339 &elem_values, &elem_nulls,
2340 &num_elems);
2342 {
2344
2345 /*
2346 * A null array element must lead to a null comparison result,
2347 * since saop_op is known strict. We can ignore it in the
2348 * useOr case, but otherwise it implies self-contradiction.
2349 */
2351 {
2353 continue;
2355 }
2356
2358 arr->constcollid, elemlen,
2361 }
2362 }
2364 {
2366
2367 /*
2368 * For a nested ArrayExpr, we don't know how to get the actual
2369 * scalar values out into a flat list, so we give up doing
2370 * anything with this ScalarArrayOpExpr.
2371 */
2374
2375 /*
2376 * Otherwise, we can just use the list of element values.
2377 */
2379 }
2380 else
2381 {
2382 /* Give up on any other clause types. */
2384 }
2385
2386 /*
2387 * Now generate a list of clauses, one for each array element, of the
2388 * form leftop saop_op elem_expr
2389 */
2392 {
2394
2399 }
2400
2401 /*
2402 * If we have an ANY clause and multiple elements, now turn the list
2403 * of clauses into an OR expression.
2404 */
2407
2408 /* Finally, generate steps */
2415 }
2417 {
2420
2424
2425 /* Does arg match with this partition key column? */
2428
2430
2432 }
2433
2434 /*
2435 * If we get here then the return value depends on the result of the
2436 * match_boolean_partition_clause call above. If the call returned
2437 * PARTCLAUSE_UNSUPPORTED then we're either not dealing with a bool qual
2438 * or the bool qual is not suitable for pruning. Since the qual didn't
2439 * match up to any of the other qual types supported here, then trying to
2440 * match it against any other partition key is a waste of time, so just
2441 * return PARTCLAUSE_UNSUPPORTED. If the qual just couldn't be matched to
2442 * this partition key, then it may match another, so return
2443 * PARTCLAUSE_NOMATCH. The only other value that
2444 * match_boolean_partition_clause can return is PARTCLAUSE_MATCH_CLAUSE,
2445 * and since that value was already dealt with above, then we can just
2446 * return boolmatchstatus.
2447 */
2449}
References arg, ScalarArrayOpExpr::args, ARR_ELEMTYPE, Assert, bms_is_empty, BTEqualStrategyNumber, BTORDER_PROC, castNode, contain_var_clause(), contain_volatile_functions(), GeneratePruningStepsContext::contradictory, copyObject, DatumGetArrayTypeP, deconstruct_array(), elog, equal(), ERROR, fb(), gen_partprune_steps_internal(), get_commutator(), get_leftop(), get_negator(), get_op_opfamily_properties(), get_opfamily_proc(), get_rightop(), get_typlenbyvalalign(), GeneratePruningStepsContext::has_exec_param, GeneratePruningStepsContext::has_mutable_arg, GeneratePruningStepsContext::has_mutable_op, HASHEXTENDED_PROC, i, InvalidOid, InvalidStrategy, IS_FALSE, IS_NOT_FALSE, IS_NOT_NULL, IS_NOT_TRUE, IS_NULL, IS_TRUE, IsA, lappend(), lfirst, linitial, list_length(), list_make1, list_make2, lsecond, make_opclause(), makeBoolExpr(), makeConst(), makeNode, match_boolean_partition_clause(), NIL, OidIsValid, op_in_opfamily(), op_strict(), op_volatile(), ScalarArrayOpExpr::opno, OR_EXPR, palloc_object, PARTCLAUSE_MATCH_CLAUSE, PARTCLAUSE_MATCH_CONTRADICT, PARTCLAUSE_MATCH_NULLNESS, PARTCLAUSE_MATCH_STEPS, PARTCLAUSE_NOMATCH, PARTCLAUSE_UNSUPPORTED, PartCollMatchesExprColl, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, PARTTARGET_EXEC, PARTTARGET_PLANNER, pull_exec_paramids(), GeneratePruningStepsContext::rel, strip_noop_phvs(), GeneratePruningStepsContext::target, and ScalarArrayOpExpr::useOr.
Referenced by gen_partprune_steps_internal().
◆ partkey_datum_from_expr()
|
static |
Definition at line 3803 of file partprune.c.
3806{
3808 {
3809 /* We can always determine the value of a constant */
3811
3812 *value = con->constvalue;
3813 *isnull = con->constisnull;
3814 }
3815 else
3816 {
3817 ExprState *exprstate;
3819
3820 /*
3821 * We should never see a non-Const in a step unless the caller has
3822 * passed a valid ExprContext.
3823 */
3825
3829 }
3830}
References Assert, ExecEvalExprSwitchContext(), PartitionPruneContext::exprcontext, PartitionPruneContext::exprstates, fb(), IsA, and value.
Referenced by perform_pruning_base_step().
◆ perform_pruning_base_step()
|
static |
Definition at line 3457 of file partprune.c.
3459{
3461 *lc2;
3462 int keyno,
3463 nvalues;
3465 FmgrInfo *partsupfunc;
3467
3468 /*
3469 * There better be the same number of expressions and compare functions.
3470 */
3472
3473 nvalues = 0;
3476
3477 /*
3478 * Generate the partition lookup key that will be used by one of the
3479 * get_matching_*_bounds functions called below.
3480 */
3482 {
3483 /*
3484 * For hash partitioning, it is possible that values of some keys are
3485 * not provided in operator clauses, but instead the planner found
3486 * that they appeared in a IS NULL clause.
3487 */
3489 continue;
3490
3491 /*
3492 * For range partitioning, we must only perform pruning with values
3493 * for either all partition keys or a prefix thereof.
3494 */
3496 break;
3497
3499 {
3500 Expr *expr;
3501 Datum datum;
3502 bool isnull;
3503 Oid cmpfn;
3504
3507 opstep->step.step_id, keyno);
3509 &datum, &isnull);
3510
3511 /*
3512 * Since we only allow strict operators in pruning steps, any
3513 * null-valued comparison value must cause the comparison to fail,
3514 * so that no partitions could match.
3515 */
3516 if (isnull)
3517 {
3519
3524
3526 }
3527
3528 /* Set up the stepcmpfuncs entry, unless we already did */
3532 {
3533 /*
3534 * If the needed support function is the same one cached in
3535 * the relation's partition key, copy the cached FmgrInfo.
3536 * Otherwise (i.e., when we have a cross-type comparison), an
3537 * actual lookup is required.
3538 */
3541 &context->partsupfunc[keyno],
3542 context->ppccontext);
3543 else
3545 context->ppccontext);
3546 }
3547
3548 values[keyno] = datum;
3549 nvalues++;
3550
3553 }
3554 }
3555
3556 /*
3557 * Point partsupfunc to the entry for the 0th key of this step; the
3558 * additional support functions, if any, follow consecutively.
3559 */
3562
3564 {
3567 opstep->opstrategy,
3568 values, nvalues,
3569 partsupfunc,
3570 opstep->nullkeys);
3571
3574 opstep->opstrategy,
3575 values[0], nvalues,
3576 &partsupfunc[0],
3577 opstep->nullkeys);
3578
3581 opstep->opstrategy,
3582 values, nvalues,
3583 partsupfunc,
3584 opstep->nullkeys);
3585
3586 default:
3589 break;
3590 }
3591
3593}
References Assert, bms_is_member(), elog, ERROR, fb(), fmgr_info_copy(), fmgr_info_cxt(), FmgrInfo::fn_oid, get_matching_hash_bounds(), get_matching_list_bounds(), get_matching_range_bounds(), lfirst, lfirst_oid, list_head(), list_length(), lnext(), OidIsValid, palloc_object, PARTITION_MAX_KEYS, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, partkey_datum_from_expr(), PartitionPruneContext::partnatts, PartitionPruneContext::partsupfunc, PartitionPruneContext::ppccontext, PruneCxtStateIdx, result, PartitionPruneContext::stepcmpfuncs, PartitionPruneContext::strategy, and values.
Referenced by get_matching_partitions().
◆ perform_pruning_combine_step()
|
static |
Definition at line 3605 of file partprune.c.
3608{
3612
3613 /*
3614 * A combine step without any source steps is an indication to not perform
3615 * any partition pruning. Return all datum indexes in that case.
3616 */
3618 {
3620
3621 result->bound_offsets =
3626 }
3627
3629 {
3632 {
3635
3636 /*
3637 * step_results[step_id] must contain a valid result, which is
3638 * confirmed by the fact that cstep's step_id is greater than
3639 * step_id and the fact that results of the individual steps
3640 * are evaluated in sequence of their step_ids.
3641 */
3646
3647 /* Record any additional datum indexes from this step */
3649 step_result->bound_offsets);
3650
3651 /* Update whether to scan null and default partitions. */
3656 }
3657 break;
3658
3662 {
3665
3670
3672 {
3673 /* Copy step's result the first time. */
3674 result->bound_offsets =
3679 }
3680 else
3681 {
3682 /* Record datum indexes common to both steps */
3683 result->bound_offsets =
3685 step_result->bound_offsets);
3686
3687 /* Update whether to scan null and default partitions. */
3692 }
3693 }
3694 break;
3695 }
3696
3698}
References Assert, bms_add_members(), bms_add_range(), bms_copy(), bms_int_members(), PartitionPruneContext::boundinfo, elog, ERROR, fb(), lfirst_int, NIL, PartitionBoundInfoData::nindexes, palloc0_object, partition_bound_accepts_nulls, partition_bound_has_default, PARTPRUNE_COMBINE_INTERSECT, PARTPRUNE_COMBINE_UNION, and result.
Referenced by get_matching_partitions().
◆ prune_append_rel_partitions()
| Bitmapset * prune_append_rel_partitions | ( | RelOptInfo * | rel | ) |
Definition at line 780 of file partprune.c.
781{
784 GeneratePruningStepsContext gcontext;
785 PartitionPruneContext context;
786
788
789 /* If there are no partitions, return the empty set */
792
793 /*
794 * If pruning is disabled or if there are no clauses to prune with, return
795 * all partitions.
796 */
799
800 /*
801 * Process clauses to extract pruning steps that are usable at plan time.
802 * If the clauses are found to be contradictory, we can return the empty
803 * set.
804 */
806 &gcontext);
810
811 /* If there's nothing usable, return all partitions */
814
815 /* Set up PartitionPruneContext */
816 context.strategy = rel->part_scheme->strategy;
817 context.partnatts = rel->part_scheme->partnatts;
819 context.boundinfo = rel->boundinfo;
820 context.partcollation = rel->part_scheme->partcollation;
821 context.partsupfunc = rel->part_scheme->partsupfunc;
825
826 /* These are not valid when being called from the planner */
830
831 /* Actual pruning happens here. */
833}
Bitmapset * get_matching_partitions(PartitionPruneContext *context, List *pruning_steps)
Definition partprune.c:846
References Assert, RelOptInfo::baserestrictinfo, bms_add_range(), PartitionPruneContext::boundinfo, GeneratePruningStepsContext::contradictory, CurrentMemoryContext, enable_partition_pruning, PartitionPruneContext::exprcontext, PartitionPruneContext::exprstates, fb(), gen_partprune_steps(), get_matching_partitions(), list_length(), NIL, RelOptInfo::nparts, PartitionPruneContext::nparts, palloc0_array, PartitionPruneContext::partcollation, PartitionPruneContext::partnatts, PartitionPruneContext::partsupfunc, PARTTARGET_PLANNER, PartitionPruneContext::planstate, PartitionPruneContext::ppccontext, PartitionPruneContext::stepcmpfuncs, GeneratePruningStepsContext::steps, and PartitionPruneContext::strategy.
Referenced by expand_partitioned_rtentry().
◆ pull_exec_paramids()
Definition at line 3388 of file partprune.c.
3389{
3391
3393
3395}
References fb(), pull_exec_paramids_walker(), and result.
Referenced by get_partkey_exec_paramids(), and match_clause_to_partition_key().
◆ pull_exec_paramids_walker()
Definition at line 3398 of file partprune.c.
3399{
3401 return false;
3403 {
3405
3408 return false;
3409 }
3411}
References bms_add_member(), expression_tree_walker, fb(), IsA, PARAM_EXEC, Param::paramid, Param::paramkind, and pull_exec_paramids_walker().
Referenced by pull_exec_paramids(), and pull_exec_paramids_walker().
