Loading...
Searching...
No Matches
nbtpreprocesskeys.c File Reference
#include "postgres.h"#include "access/nbtree.h"#include "access/relscan.h"#include "common/int.h"#include "lib/qunique.h"#include "utils/array.h"#include "utils/lsyscache.h"#include "utils/memutils.h"#include "utils/rel.h"
Include dependency graph for nbtpreprocesskeys.c:
Go to the source code of this file.
Data Structures | |
| struct | BTScanKeyPreproc |
| struct | BTSortArrayContext |
Typedefs | |
| typedef struct BTScanKeyPreproc | BTScanKeyPreproc |
| typedef struct BTSortArrayContext | BTSortArrayContext |
Typedef Documentation
◆ BTScanKeyPreproc
◆ BTSortArrayContext
Function Documentation
◆ _bt_compare_array_elements()
Definition at line 2844 of file nbtpreprocesskeys.c.
2845{
2850
2852 cxt->collation,
2853 da, db));
2857}
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition fmgr.c:1150
Definition nbtpreprocesskeys.c:35
References a, arg, b, BTSortArrayContext::collation, compare(), DatumGetInt32(), fb(), FunctionCall2Coll(), INVERT_COMPARE_RESULT, BTSortArrayContext::reverse, and BTSortArrayContext::sortproc.
Referenced by _bt_merge_arrays(), and _bt_sort_array_elements().
◆ _bt_compare_array_scankey_args()
|
static |
Definition at line 1097 of file nbtpreprocesskeys.c.
1100{
1105 /* don't expect to have to deal with NULLs/row comparison scan keys */
1109
1110 /*
1111 * Just call the appropriate helper function based on whether it's a SAOP
1112 * array or a skip array. Both helpers will set *qual_ok in passing.
1113 */
1116 qual_ok);
1117 else
1119}
static bool _bt_saoparray_shrink(IndexScanDesc scan, ScanKey arraysk, ScanKey skey, FmgrInfo *orderproc, BTArrayKeyInfo *array, bool *qual_ok)
Definition nbtpreprocesskeys.c:1135
static bool _bt_skiparray_shrink(IndexScanDesc scan, ScanKey skey, BTArrayKeyInfo *array, bool *qual_ok)
Definition nbtpreprocesskeys.c:1260
References _bt_saoparray_shrink(), _bt_skiparray_shrink(), Assert, BTEqualStrategyNumber, fb(), BTArrayKeyInfo::num_elems, SK_ISNULL, SK_ROW_HEADER, SK_ROW_MEMBER, and SK_SEARCHARRAY.
Referenced by _bt_compare_scankey_args().
◆ _bt_compare_scankey_args()
|
static |
Definition at line 870 of file nbtpreprocesskeys.c.
874{
876 Oid lefttype,
877 righttype,
878 optype,
879 opcintype,
880 cmp_op;
882
884
885 /*
886 * First, deal with cases where one or both args are NULL. This should
887 * only happen when the scankeys represent IS NULL/NOT NULL conditions.
888 */
890 {
892 rightnull;
893
894 /* Handle skip array comparison with IS NOT NULL scan key */
896 {
897 /* Shouldn't generate skip array in presence of IS NULL key */
900
901 /* Skip array will have no NULL element/IS NULL scan key */
904
905 /* IS NOT NULL key (could be leftarg or rightarg) now redundant */
906 *result = true;
907 return true;
908 }
909
911 {
914 }
915 else
918 {
921 }
922 else
924
925 /*
926 * We treat NULL as either greater than or less than all other values.
927 * Since true > false, the tests below work correctly for NULLS LAST
928 * logic. If the index is NULLS FIRST, we need to flip the strategy.
929 */
933
935 {
938 break;
941 break;
944 break;
947 break;
950 break;
951 default:
953 *result = false; /* keep compiler quiet */
954 break;
955 }
956 return true;
957 }
958
959 /*
960 * We don't yet know how to determine redundancy when it involves a row
961 * compare key (barring simple cases involving IS NULL/IS NOT NULL)
962 */
964 {
966 return false;
967 }
968
969 /*
970 * If either leftarg or rightarg are equality-type array scankeys, we need
971 * specialized handling (since by now we know that IS NULL wasn't used)
972 */
973 if (array)
974 {
976 rightarray;
977
982
983 /*
984 * _bt_preprocess_array_keys is responsible for merging together array
985 * scan keys, and will do so whenever the opfamily has the required
986 * cross-type support. If it failed to do that, we handle it just
987 * like the case where we can't make the comparison ourselves.
988 */
990 {
991 /* Can't make the comparison */
992 *result = false; /* suppress compiler warnings */
994 return false;
995 }
996
997 /*
998 * Otherwise we need to determine if either one of leftarg or rightarg
999 * uses an array, then pass this through to a dedicated helper
1000 * function.
1001 */
1004 orderproc, array, result);
1007 orderproc, array, result);
1008
1009 /* FALL THRU */
1010 }
1011
1012 /*
1013 * The opfamily we need to worry about is identified by the index column.
1014 */
1016
1018
1019 /*
1020 * Determine the actual datatypes of the ScanKey arguments. We have to
1021 * support the convention that sk_subtype == InvalidOid means the opclass
1022 * input type; this is a hack to simplify life for ScanKeyInit().
1023 */
1024 lefttype = leftarg->sk_subtype;
1026 lefttype = opcintype;
1027 righttype = rightarg->sk_subtype;
1029 righttype = opcintype;
1032 optype = opcintype;
1033
1034 /*
1035 * If leftarg and rightarg match the types expected for the "op" scankey,
1036 * we can use its already-looked-up comparison function.
1037 */
1039 {
1041 op->sk_collation,
1042 leftarg->sk_argument,
1043 rightarg->sk_argument));
1044 return true;
1045 }
1046
1047 /*
1048 * Otherwise, we need to go to the syscache to find the appropriate
1049 * operator. (This cannot result in infinite recursion, since no
1050 * indexscan initiated by syscache lookup will use cross-data-type
1051 * operators.)
1052 *
1053 * If the sk_strategy was flipped by _bt_fix_scankey_strategy, we have to
1054 * un-flip it to get the correct opfamily member.
1055 */
1059
1061 lefttype,
1062 righttype,
1063 strat);
1065 {
1067
1069 {
1071 op->sk_collation,
1072 leftarg->sk_argument,
1073 rightarg->sk_argument));
1074 return true;
1075 }
1076 }
1077
1078 /* Can't make the comparison */
1079 *result = false; /* suppress compiler warnings */
1080 return false;
1081}
Datum OidFunctionCall2Coll(Oid functionId, Oid collation, Datum arg1, Datum arg2)
Definition fmgr.c:1422
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition lsyscache.c:168
static bool _bt_compare_array_scankey_args(IndexScanDesc scan, ScanKey arraysk, ScanKey skey, FmgrInfo *orderproc, BTArrayKeyInfo *array, bool *qual_ok)
Definition nbtpreprocesskeys.c:1097
Definition rel.h:56
References _bt_compare_array_scankey_args(), Assert, BTCommuteStrategyNumber, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, DatumGetBool(), elog, ERROR, fb(), FunctionCall2Coll(), get_opcode(), get_opfamily_member(), IndexScanDescData::indexRelation, InvalidOid, BTArrayKeyInfo::null_elem, BTArrayKeyInfo::num_elems, OidFunctionCall2Coll(), OidIsValid, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, SK_BT_DESC, SK_BT_NULLS_FIRST, SK_BT_SKIP, ScanKeyData::sk_collation, ScanKeyData::sk_flags, ScanKeyData::sk_func, SK_ISNULL, SK_ROW_HEADER, SK_ROW_MEMBER, SK_SEARCHARRAY, SK_SEARCHNOTNULL, SK_SEARCHNULL, ScanKeyData::sk_strategy, and ScanKeyData::sk_subtype.
Referenced by _bt_preprocess_keys(), and _bt_skiparray_shrink().
◆ _bt_find_extreme_element()
|
static |
Definition at line 2579 of file nbtpreprocesskeys.c.
2582{
2585 RegProcedure cmp_proc;
2586 FmgrInfo flinfo;
2587 Datum result;
2589
2590 /*
2591 * Look up the appropriate comparison operator in the opfamily.
2592 *
2593 * Note: it's possible that this would fail, if the opfamily is
2594 * incomplete, but it seems quite unlikely that an opfamily would omit
2595 * non-cross-type comparison operators for any datatype that it supports
2596 * at all.
2597 */
2601 elemtype,
2602 elemtype,
2603 strat);
2606 strat, elemtype, elemtype,
2611
2612 fmgr_info(cmp_proc, &flinfo);
2613
2614 Assert(nelems > 0);
2615 result = elems[0];
2617 {
2619 skey->sk_collation,
2620 elems[i],
2621 result)))
2622 result = elems[i];
2623 }
2624
2625 return result;
2626}
References Assert, BTEqualStrategyNumber, DatumGetBool(), elog, ERROR, fb(), fmgr_info(), FunctionCall2Coll(), get_opcode(), get_opfamily_member(), i, IndexScanDescData::indexRelation, OidIsValid, RelationData::rd_opfamily, and RegProcedureIsValid.
Referenced by _bt_preprocess_array_keys().
◆ _bt_fix_scankey_strategy()
Definition at line 668 of file nbtpreprocesskeys.c.
669{
671
673
674 /*
675 * We treat all btree operators as strict (even if they're not so marked
676 * in pg_proc). This means that it is impossible for an operator condition
677 * with a NULL comparison constant to succeed, and we can reject it right
678 * away.
679 *
680 * However, we now also support "x IS NULL" clauses as search conditions,
681 * so in that case keep going. The planner has not filled in any
682 * particular strategy in this case, so set it to BTEqualStrategyNumber
683 * --- we can treat IS NULL as an equality operator for purposes of search
684 * strategy.
685 *
686 * Likewise, "x IS NOT NULL" is supported. We treat that as either "less
687 * than NULL" in a NULLS LAST index, or "greater than NULL" in a NULLS
688 * FIRST index.
689 *
690 * Note: someday we might have to fill in sk_collation from the index
691 * column's collation. At the moment this is a non-issue because we'll
692 * never actually call the comparison operator on a NULL.
693 */
695 {
696 /* SK_ISNULL shouldn't be set in a row header scankey */
698
699 /* Set indoption flags in scankey (might be done already) */
701
702 /* Set correct strategy for IS NULL or NOT NULL search */
704 {
708 }
710 {
713 else
717 }
718 else
719 {
720 /* regular qual, so it cannot be satisfied */
721 return false;
722 }
723
724 /* Needn't do the rest */
725 return true;
726 }
727
728 /* Adjust strategy for DESC, if we didn't already */
732
733 /* If it's a row header, fix row member flags and strategies similarly */
735 {
737
739 {
740 /* First row member is NULL, so RowCompare is unsatisfiable */
742 return false;
743 }
744
745 for (;;)
746 {
753 break;
754 subkey++;
755 }
756 }
757
758 return true;
759}
Definition skey.h:65
References Assert, BTCommuteStrategyNumber, BTEqualStrategyNumber, BTGreaterStrategyNumber, BTLessStrategyNumber, DatumGetPointer(), fb(), InvalidOid, SK_BT_DESC, SK_BT_INDOPTION_SHIFT, SK_BT_NULLS_FIRST, SK_ISNULL, SK_ROW_END, SK_ROW_HEADER, SK_ROW_MEMBER, SK_SEARCHNOTNULL, and SK_SEARCHNULL.
Referenced by _bt_preprocess_keys().
◆ _bt_mark_scankey_required()
Definition at line 780 of file nbtpreprocesskeys.c.
781{
783
785 {
789 break;
792 break;
796 break;
797 default:
801 break;
802 }
803
805
807 {
810
811 /* First subkey should be same column/operator as the header */
814
815 for (;;)
816 {
819 break; /* non-adjacent key, so not required */
821 break; /* wrong direction, so not required */
824 break;
825 subkey++;
826 attno++;
827 }
828 }
829}
References Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, DatumGetPointer(), elog, ERROR, fb(), ScanKeyData::sk_attno, SK_BT_REQBKWD, SK_BT_REQFWD, SK_ROW_END, SK_ROW_HEADER, and SK_ROW_MEMBER.
Referenced by _bt_preprocess_keys().
◆ _bt_merge_arrays()
|
static |
Definition at line 2776 of file nbtpreprocesskeys.c.
2780{
2783 BTSortArrayContext cxt;
2785 nelems_orig_merged = 0;
2788
2791
2793 {
2794 RegProcedure cmp_proc;
2795
2796 /*
2797 * Cross-array-element-type merging is required, so can't just reuse
2798 * sortproc when merging
2799 */
2803 {
2804 /* Can't make the required comparisons */
2805 return false;
2806 }
2807
2808 /* We have all we need to determine redundancy/contradictoriness */
2811 }
2812
2815 cxt.reverse = reverse;
2816
2818 {
2822
2823 if (res == 0)
2824 {
2826 i++;
2827 j++;
2828 }
2829 else if (res < 0)
2830 i++;
2831 else /* res > 0 */
2832 j++;
2833 }
2834
2836
2837 return true;
2838}
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition fmgr.c:138
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition lsyscache.c:872
static int _bt_compare_array_elements(const void *a, const void *b, void *arg)
Definition nbtpreprocesskeys.c:2844
Definition nbtree.h:1054
References _bt_compare_array_elements(), Assert, BTEqualStrategyNumber, BTORDER_PROC, BTSortArrayContext::collation, fb(), fmgr_info_cxt(), get_opfamily_proc(), i, IndexScanDescData::indexRelation, j, OidIsValid, IndexScanDescData::opaque, RelationData::rd_opfamily, RegProcedureIsValid, BTSortArrayContext::reverse, and BTSortArrayContext::sortproc.
Referenced by _bt_preprocess_array_keys().
◆ _bt_num_array_keys()
|
static |
Definition at line 2413 of file nbtpreprocesskeys.c.
2415{
2418 attno_inkey = 1;
2422 numSkipArrayKeys,
2423 prev_numSkipArrayKeys;
2424
2426
2427 /* Initial pass over input scan keys counts the number of SAOP arrays */
2428 numSAOPArrayKeys = 0;
2431 {
2433
2435 numSAOPArrayKeys++;
2436 }
2437
2438#ifdef DEBUG_DISABLE_SKIP_SCAN
2439 /* don't attempt to add skip arrays */
2441#endif
2442
2444 {
2446
2447 /*
2448 * Backfill skip arrays for any wholly omitted attributes prior to
2449 * attno_inkey
2450 */
2452 {
2455
2456 /* Look up input opclass's equality operator (might fail) */
2458 get_opfamily_member(opfamily, opcintype, opcintype,
2459 BTEqualStrategyNumber);
2461 {
2462 /*
2463 * Cannot generate a skip array for this or later attributes
2464 * (input opclass lacks an equality strategy operator)
2465 */
2468 }
2469
2470 /* plan on adding a backfill skip array for this attribute */
2471 numSkipArrayKeys++;
2472 attno_skip++;
2473 }
2474
2476
2477 /*
2478 * Stop once past the final input scan key. We deliberately never add
2479 * a skip array for the last input scan key's attribute -- even when
2480 * there are only inequality keys on that attribute.
2481 */
2483 break;
2484
2485 /*
2486 * Later preprocessing steps cannot merge a RowCompare into a skip
2487 * array, so stop adding skip arrays once we see one. (Note that we
2488 * can backfill skip arrays before a RowCompare, which will allow keys
2489 * up to and including the RowCompare to be marked required.)
2490 *
2491 * Skip arrays work by maintaining a current array element value,
2492 * which anchors lower-order keys via an implied equality constraint.
2493 * This is incompatible with the current nbtree row comparison design,
2494 * which compares all columns together, as an indivisible group.
2495 * Alternative designs that can be used alongside skip arrays are
2496 * possible, but it's not clear that they're really worth pursuing.
2497 *
2498 * A RowCompare qual "(a, b, c) > (10, 'foo', 42)" is equivalent to
2499 * "(a=10 AND b='foo' AND c>42) OR (a=10 AND b>'foo') OR (a>10)".
2500 * Decomposing this RowCompare into these 3 disjuncts allows each
2501 * disjunct to be executed as a separate "single value" index scan.
2502 * That'll give all 3 scans the ability to add skip arrays in the
2503 * usual way (when there are any scalar keys after the RowCompare).
2504 * Under this scheme, a qual "(a, b, c) > (10, 'foo', 42) AND d = 99"
2505 * performs 3 separate scans, each of which can mark keys up to and
2506 * including its "d = 99" key as required to continue the scan.
2507 */
2509 break;
2510
2511 /*
2512 * Now consider next attno_inkey (or keep going if this is an
2513 * additional scan key against the same attribute)
2514 */
2516 {
2517 /*
2518 * Now add skip array for previous scan key's attribute, though
2519 * only if the attribute has no equality strategy scan keys
2520 */
2522 {
2523 /* Attributes with an = key must have InvalidOid eq_op set */
2525 }
2526 else
2527 {
2530
2531 /* Look up input opclass's equality operator (might fail) */
2533 get_opfamily_member(opfamily, opcintype, opcintype,
2534 BTEqualStrategyNumber);
2535
2537 {
2538 /*
2539 * Input opclass lacks an equality strategy operator, so
2540 * don't generate a skip array that definitely won't work
2541 */
2542 break;
2543 }
2544
2545 /* plan on adding a backfill skip array for this attribute */
2546 numSkipArrayKeys++;
2547 }
2548
2549 /* Set things up for this new attribute */
2550 attno_skip++;
2553 }
2554
2555 /*
2556 * Track if this attribute's scan keys include any equality strategy
2557 * scan keys (IS NULL keys count as equality keys here). Also track
2558 * if it has any RowCompare keys.
2559 */
2565 }
2566
2569}
References Assert, BTEqualStrategyNumber, fb(), get_opfamily_member(), i, IndexScanDescData::indexRelation, InvalidOid, IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, OidIsValid, RelationData::rd_opcintype, RelationData::rd_opfamily, ScanKeyData::sk_attno, ScanKeyData::sk_flags, SK_ROW_HEADER, SK_SEARCHARRAY, SK_SEARCHNULL, and ScanKeyData::sk_strategy.
Referenced by _bt_preprocess_array_keys().
◆ _bt_preprocess_array_keys()
|
static |
Definition at line 1845 of file nbtpreprocesskeys.c.
1846{
1851 int numArrayKeys,
1852 numSkipArrayKeys,
1853 numArrayKeyData;
1856 origarraykey = -1;
1860
1861 /*
1862 * Check the number of input array keys within scan->keyData[] input keys
1863 * (also checks if we should add extra skip arrays based on input keys)
1864 */
1867
1868 /* Quit if nothing to do. */
1869 if (numArrayKeys == 0)
1871
1872 /*
1873 * Estimated final size of arrayKeyData[] array we'll return to our caller
1874 * is the size of the original scan->keyData[] input array, plus space for
1875 * any additional skip array scan keys we'll need to generate below
1876 */
1878
1879 /*
1880 * Make a scan-lifespan context to hold array-associated data, or reset it
1881 * if we already have one from a previous rescan cycle.
1882 */
1885 "BTree array context",
1886 ALLOCSET_SMALL_SIZES);
1887 else
1889
1891
1892 /* Create output scan keys in the workspace context */
1894
1895 /* Allocate space for per-array data in the workspace context */
1897
1898 /* Allocate space for ORDER procs used to help _bt_checkkeys */
1900
1901 numArrayKeys = 0;
1902 numArrayKeyData = 0;
1904 {
1906 cur;
1907 FmgrInfo sortproc;
1909 Oid elemtype;
1910 bool reverse;
1915 int num_elems;
1916 Datum *elem_values;
1917 bool *elem_nulls;
1919
1920 /* set up next output scan key */
1922
1923 /* Backfill skip arrays for attrs < or <= input key's attr? */
1925 {
1930 CompactAttribute *attr;
1931 RegProcedure cmp_proc;
1932
1934 {
1935 /*
1936 * Attribute already has an = input key, so don't output a
1937 * skip array for attno_skip. Just copy attribute's = input
1938 * key into arrayKeyData[] once outside this inner loop.
1939 *
1940 * Note: When we get here there must be a later attribute that
1941 * lacks an equality input key, and still needs a skip array
1942 * (if there wasn't then numSkipArrayKeys would be 0 by now).
1943 */
1945 /* inkey can't be last input key to be marked required: */
1947#if 0
1948 /* Could be a redundant input scan key, so can't do this: */
1951#endif
1952
1953 attno_skip++;
1954 break;
1955 }
1956
1960
1966 collation, /* index column's collation */
1967 cmp_proc, /* equality operator's proc */
1969
1970 /* Initialize generic BTArrayKeyInfo fields */
1972 so->arrayKeys[numArrayKeys].num_elems = -1;
1973
1974 /* Initialize skip array specific BTArrayKeyInfo fields */
1980 so->arrayKeys[numArrayKeys].sksup =
1981 PrepareSkipSupportFromOpclass(opfamily, opcintype, reverse);
1984
1985 /*
1986 * We'll need a 3-way ORDER proc. Set that up now.
1987 */
1990
1991 numArrayKeys++;
1993
1994 /* set up next output scan key */
1996
1997 /* remember having output this skip array and scan key */
1998 numSkipArrayKeys--;
1999 attno_skip++;
2000 }
2001
2002 /*
2003 * Provisionally copy scan key into arrayKeyData[] array we'll return
2004 * to _bt_preprocess_keys caller
2005 */
2006 *cur = *inkey;
2007
2009 {
2011 continue;
2012 }
2013
2014 /*
2015 * Process SAOP array scan key
2016 */
2018
2019 /* If array is null as a whole, the scan qual is unsatisfiable */
2021 {
2023 break;
2024 }
2025
2026 /*
2027 * Deconstruct the array into elements
2028 */
2030 /* We could cache this data, but not clear it's worth it */
2036 &elem_values, &elem_nulls, &num_elems);
2037
2038 /*
2039 * Compress out any null elements. We can ignore them since we assume
2040 * all btree operators are strict.
2041 */
2042 num_nonnulls = 0;
2044 {
2047 }
2048
2049 /* We could pfree(elem_nulls) now, but not worth the cycles */
2050
2051 /* If there's no non-nulls, the scan qual is unsatisfiable */
2053 {
2055 break;
2056 }
2057
2058 /*
2059 * Determine the nominal datatype of the array elements. We have to
2060 * support the convention that sk_subtype == InvalidOid means the
2061 * opclass input type; this is a hack to simplify life for
2062 * ScanKeyInit().
2063 */
2064 elemtype = cur->sk_subtype;
2067
2068 /*
2069 * If the comparison operator is not equality, then the array qual
2070 * degenerates to a simple comparison against the smallest or largest
2071 * non-null array element, as appropriate.
2072 */
2074 {
2077 cur->sk_argument =
2079 BTGreaterStrategyNumber,
2080 elem_values, num_nonnulls);
2082 continue;
2084 /* proceed with rest of loop */
2085 break;
2088 cur->sk_argument =
2090 BTLessStrategyNumber,
2091 elem_values, num_nonnulls);
2093 continue;
2094 default:
2097 break;
2098 }
2099
2100 /*
2101 * We'll need a 3-way ORDER proc to perform binary searches for the
2102 * next matching array element. Set that up now.
2103 *
2104 * Array scan keys with cross-type equality operators will require a
2105 * separate same-type ORDER proc for sorting their array. Otherwise,
2106 * sortproc just points to the same proc used during binary searches.
2107 */
2110
2111 /*
2112 * Sort the non-null elements and eliminate any duplicates. We must
2113 * sort in the same ordering used by the index column, so that the
2114 * arrays can be advanced in lockstep with the scan's progress through
2115 * the index's key space.
2116 */
2119 elem_values, num_nonnulls);
2120
2122 {
2124
2125 /*
2126 * This array scan key is redundant with a previous equality
2127 * operator array scan key. Merge the two arrays together to
2128 * eliminate contradictory non-intersecting elements (or try to).
2129 *
2130 * We merge this next array back into attribute's original array.
2131 */
2134 cur->sk_collation);
2136 origelemtype, elemtype,
2138 elem_values, num_elems))
2139 {
2140 /* Successfully eliminated this array */
2141 pfree(elem_values);
2142
2143 /*
2144 * If no intersecting elements remain in the original array,
2145 * the scan qual is unsatisfiable
2146 */
2148 {
2150 break;
2151 }
2152
2153 /* Throw away this scan key/array */
2154 continue;
2155 }
2156
2157 /*
2158 * Unable to merge this array with previous array due to a lack of
2159 * suitable cross-type opfamily support. Will need to keep both
2160 * scan keys/arrays.
2161 */
2162 }
2163 else
2164 {
2165 /*
2166 * This array is the first for current index attribute.
2167 *
2168 * If it turns out to not be the last array (that is, if the next
2169 * array is redundantly applied to this same index attribute),
2170 * we'll then treat this array as the attribute's "original" array
2171 * when merging.
2172 */
2174 origarraykey = numArrayKeys;
2175 origelemtype = elemtype;
2176 }
2177
2178 /* Initialize generic BTArrayKeyInfo fields */
2180 so->arrayKeys[numArrayKeys].num_elems = num_elems;
2181
2182 /* Initialize SAOP array specific BTArrayKeyInfo fields */
2183 so->arrayKeys[numArrayKeys].elem_values = elem_values;
2185
2186 numArrayKeys++;
2188 }
2189
2191
2192 /* Set final number of equality-type array keys */
2193 so->numArrayKeys = numArrayKeys;
2194 /* Set number of scan keys in arrayKeyData[] */
2196
2198
2200}
void deconstruct_array(const ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3632
void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)
Definition lsyscache.c:2421
static bool _bt_merge_arrays(IndexScanDesc scan, ScanKey skey, FmgrInfo *sortproc, bool reverse, Oid origelemtype, Oid nextelemtype, Datum *elems_orig, int *nelems_orig, Datum *elems_next, int nelems_next)
Definition nbtpreprocesskeys.c:2776
static int _bt_num_array_keys(IndexScanDesc scan, Oid *skip_eq_ops_out, int *numSkipArrayKeys_out)
Definition nbtpreprocesskeys.c:2413
static void _bt_setup_array_cmp(IndexScanDesc scan, ScanKey skey, Oid elemtype, FmgrInfo *orderproc, FmgrInfo **sortprocp)
Definition nbtpreprocesskeys.c:2652
static int _bt_sort_array_elements(ScanKey skey, FmgrInfo *sortproc, bool reverse, Datum *elems, int nelems)
Definition nbtpreprocesskeys.c:2732
static Datum _bt_find_extreme_element(IndexScanDesc scan, ScanKey skey, Oid elemtype, StrategyNumber strat, const Datum *elems, int nelems)
Definition nbtpreprocesskeys.c:2579
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
void ScanKeyEntryInitialize(ScanKey entry, int flags, AttrNumber attributeNumber, StrategyNumber strategy, Oid subtype, Oid collation, RegProcedure procedure, Datum argument)
Definition scankey.c:32
SkipSupport PrepareSkipSupportFromOpclass(Oid opfamily, Oid opcintype, bool reverse)
Definition skipsupport.c:30
Definition array.h:93
Definition nbtree.h:1035
Definition tupdesc.h:69
Definition memnodes.h:118
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:175
References _bt_find_extreme_element(), _bt_merge_arrays(), _bt_num_array_keys(), _bt_setup_array_cmp(), _bt_sort_array_elements(), ALLOCSET_SMALL_SIZES, AllocSetContextCreate, ARR_ELEMTYPE, Assert, CompactAttribute::attbyval, CompactAttribute::attlen, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, cur, CurrentMemoryContext, DatumGetArrayTypeP, deconstruct_array(), elog, ERROR, fb(), get_opcode(), get_typlenbyvalalign(), INDEX_MAX_KEYS, IndexScanDescData::indexRelation, InvalidAttrNumber, InvalidOid, j, IndexScanDescData::keyData, MemoryContextReset(), MemoryContextSwitchTo(), IndexScanDescData::numberOfKeys, OidIsValid, IndexScanDescData::opaque, palloc(), pfree(), PrepareSkipSupportFromOpclass(), RelationData::rd_indcollation, RelationData::rd_indoption, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, RelationGetDescr, ScanKeyEntryInitialize(), ScanKeyData::sk_attno, SK_BT_SKIP, ScanKeyData::sk_flags, SK_ISNULL, SK_ROW_HEADER, SK_SEARCHARRAY, SK_SEARCHNOTNULL, SK_SEARCHNULL, ScanKeyData::sk_strategy, and TupleDescCompactAttr().
Referenced by _bt_preprocess_keys().
◆ _bt_preprocess_array_keys_final()
|
static |
Definition at line 2225 of file nbtpreprocesskeys.c.
2226{
2229 int arrayidx = 0;
2231
2233
2234 /*
2235 * Nothing for us to do when _bt_preprocess_array_keys only had to deal
2236 * with array inequalities
2237 */
2239 return;
2240
2242 {
2246
2248
2250 continue;
2251
2253
2257
2258 /*
2259 * We're lazy about looking up ORDER procs for non-array keys, since
2260 * not all input keys become output keys. Take care of it now.
2261 */
2263 {
2264 Oid elemtype;
2265
2266 /* No need for an ORDER proc given an IS NULL scan key */
2268 continue;
2269
2270 /*
2271 * A non-required scan key doesn't need an ORDER proc, either
2272 * (unless it's associated with an array, which this one isn't)
2273 */
2275 continue;
2276
2277 elemtype = outkey->sk_subtype;
2280
2283 continue;
2284 }
2285
2286 /*
2287 * Reorder existing array scan key so->orderProcs[] entries.
2288 *
2289 * Doing this in-place is safe because preprocessing is required to
2290 * output all equality strategy scan keys in original input order
2291 * (among each group of entries against the same index attribute).
2292 * This is also the order that the arrays themselves appear in.
2293 */
2295
2296 /* Fix-up array->scan_key references for arrays */
2298 {
2300
2301 /*
2302 * All skip arrays must be marked required, and final column can
2303 * never have a skip array
2304 */
2309
2311 {
2312 /* found it */
2314 found = true;
2315
2316 /*
2317 * Transform array scan keys that have exactly 1 element
2318 * remaining (following all prior preprocessing) into
2319 * equivalent non-array scan keys.
2320 */
2322 {
2325 so->numArrayKeys--;
2326
2327 /* If we're out of array keys, we can quit right away */
2329 return;
2330
2331 /* Shift other arrays forward */
2332 memmove(array, array + 1,
2334 (so->numArrayKeys - arrayidx));
2335
2336 /*
2337 * Don't increment arrayidx (there was an entry that was
2338 * just shifted forward to the offset at arrayidx, which
2339 * will still need to be matched)
2340 */
2341 }
2342 else
2343 {
2344 /*
2345 * Any skip array low_compare and high_compare scan keys
2346 * are now final. Transform the array's > low_compare key
2347 * into a >= key (and < high_compare keys into a <= key).
2348 */
2350 !array->null_elem)
2352
2353 /* Match found, so done with this array */
2354 arrayidx++;
2355 }
2356
2357 break;
2358 }
2359 }
2360
2361 Assert(found);
2362 }
2363
2364 /*
2365 * Parallel index scans require space in shared memory to store the
2366 * current array elements (for arrays kept by preprocessing) to schedule
2367 * the next primitive index scan. The underlying structure is protected
2368 * using an LWLock, so defensively limit its size. In practice this can
2369 * only affect parallel scans that use an incomplete opfamily.
2370 */
2374 errmsg_internal("number of array scan keys left by preprocessing (%d) exceeds the maximum allowed by parallel btree index scans (%d)",
2376}
static void _bt_skiparray_strat_adjust(IndexScanDesc scan, ScanKey arraysk, BTArrayKeyInfo *array)
Definition nbtpreprocesskeys.c:1382
#define IndexRelationGetNumberOfKeyAttributes(relation)
Definition rel.h:533
struct ParallelIndexScanDescData * parallel_scan
Definition relscan.h:192
References _bt_setup_array_cmp(), _bt_skiparray_strat_adjust(), Assert, BTEqualStrategyNumber, BTArrayKeyInfo::elem_values, ereport, errcode(), errmsg_internal(), ERROR, fb(), INDEX_MAX_KEYS, IndexScanDescData::indexRelation, IndexRelationGetNumberOfKeyAttributes, InvalidOid, InvalidStrategy, BTArrayKeyInfo::null_elem, BTArrayKeyInfo::num_elems, IndexScanDescData::opaque, IndexScanDescData::parallel_scan, PG_USED_FOR_ASSERTS_ONLY, RelationData::rd_opcintype, BTArrayKeyInfo::scan_key, SK_BT_REQFWD, SK_SEARCHARRAY, SK_SEARCHNULL, and BTArrayKeyInfo::sksup.
Referenced by _bt_preprocess_keys().
◆ _bt_preprocess_keys()
| void _bt_preprocess_keys | ( | IndexScanDesc | scan | ) |
Definition at line 203 of file nbtpreprocesskeys.c.
204{
214 AttrNumber attno;
217 int arrayidx = 0;
218
220 {
221 /*
222 * Only need to do preprocessing once per btrescan, at most. All
223 * calls after the first are handled as no-ops.
224 */
225 return;
226 }
227
228 /* initialize result variables */
230 so->numberOfKeys = 0;
231
232 if (numberOfKeys < 1)
233 return; /* done if qual-less scan */
234
235 /* If any keys are SK_SEARCHARRAY type, set up array-key info */
238 {
239 /* unmatchable array, so give up */
240 return;
241 }
242
243 /*
244 * Treat arrayKeyData[] (a partially preprocessed copy of scan->keyData[])
245 * as our input if _bt_preprocess_array_keys just allocated it, else just
246 * use scan->keyData[]
247 */
249 {
251
252 /* Also maintain keyDataMap for remapping so->orderProcs[] later */
254 numberOfKeys * sizeof(int));
255
256 /*
257 * Also enlarge output array when it might otherwise not have room for
258 * a skip array's scan key
259 */
263 }
264 else
266
267 /* we check that input keys are correctly ordered */
270
271 /* We can short-circuit most of the work if there's just one key */
272 if (numberOfKeys == 1)
273 {
274 /* Apply indoption to scankey (might change sk_strategy!) */
278 so->numberOfKeys = 1;
279 /* We can mark the qual as required if it's for first index col */
283 {
284 /*
285 * Don't call _bt_preprocess_array_keys_final in this fast path
286 * (we'll miss out on the single value array transformation, but
287 * that's not nearly as important when there's only one scan key)
288 */
291 (so->arrayKeys[0].scan_key == 0 &&
294 }
295
296 return;
297 }
298
299 /*
300 * Otherwise, do the full set of pushups.
301 */
302 new_numberOfKeys = 0;
303 numberOfEqualCols = 0;
304
305 /*
306 * Initialize for processing of keys for attr 1.
307 *
308 * xform[i] points to the currently best scan key of strategy type i+1; it
309 * is NULL if we haven't yet found such a key for this attr.
310 */
311 attno = 1;
313
314 /*
315 * Loop iterates from 0 to numberOfKeys inclusive; we use the last pass to
316 * handle after-last-key processing. Actual exit from the loop is at the
317 * "break" statement below.
318 */
320 {
323
325 {
326 /* Apply indoption to scankey (might change sk_strategy!) */
328 {
329 /* NULL can't be matched, so give up */
331 return;
332 }
333 }
334
335 /*
336 * If we are at the end of the keys for a particular attr, finish up
337 * processing and emit the cleaned-up keys.
338 */
340 {
342
343 /* check input keys are correctly ordered */
346
347 /*
348 * If = has been specified, all other keys can be eliminated as
349 * redundant. Note that this is no less true if the = key is
350 * SEARCHARRAY; the only real difference is that the inequality
351 * key _becomes_ redundant by making _bt_compare_scankey_args
352 * eliminate the subset of elements that won't need to be matched
353 * (with SAOP arrays and skip arrays alike).
354 *
355 * If we have a case like "key = 1 AND key > 2", we set qual_ok to
356 * false and abandon further processing. We'll do the same thing
357 * given a case like "key IN (0, 1) AND key > 2".
358 *
359 * We also have to deal with the case of "key IS NULL", which is
360 * unsatisfiable in combination with any other index condition. By
361 * the time we get here, that's been classified as an equality
362 * check, and we've rejected any combination of it with a regular
363 * equality condition; but not with other types of conditions.
364 */
366 {
370
372 {
374 eq_arrayidx;
375
380
383 }
384
386 {
388
390 continue;
391
393 {
394 /* IS NULL is contradictory to anything else */
396 return;
397 }
398
400 array, orderproc,
401 &test_result))
402 {
404 {
405 /* keys proven mutually contradictory */
407 return;
408 }
409 /* else discard the redundant non-equality key */
412 }
413 else
415 }
416 /* track number of attrs for which we have "=" keys */
417 numberOfEqualCols++;
418 }
419
420 /* try to keep only one of <, <= */
423 {
426
428 &test_result))
429 {
432 else
434 }
435 else
437 }
438
439 /* try to keep only one of >, >= */
442 {
445
447 &test_result))
448 {
451 else
453 }
454 else
456 }
457
458 /*
459 * Emit the cleaned-up keys into the so->keyData[] array, and then
460 * mark them if they are required. They are required (possibly
461 * only in one direction) if all attrs before this one had "=".
462 *
463 * In practice we'll rarely output non-required scan keys here;
464 * typically, _bt_preprocess_array_keys has already added "=" keys
465 * sufficient to form an unbroken series of "=" constraints on all
466 * attrs prior to the attr from the final scan->keyData[] key.
467 */
469 {
471 {
473
479 }
480 }
481
482 /*
483 * Exit loop here if done.
484 */
486 break;
487
488 /* Re-initialize for new attno */
489 attno = inkey->sk_attno;
491 }
492
493 /* check strategy this key's operator corresponds to */
494 j = inkey->sk_strategy - 1;
495
497 (inkey->sk_flags & SK_SEARCHARRAY))
498 {
499 /* must track how input scan keys map to arrays */
501 arrayidx++;
502 }
503
504 /*
505 * have we seen a scan key for this same attribute and using this same
506 * operator strategy before now?
507 */
509 {
510 /* nope, so this scan key wins by default (at least for now) */
514 }
515 else
516 {
519
520 /*
521 * Seen one of these before, so keep only the more restrictive key
522 * if possible
523 */
525 {
526 /*
527 * Have to set up array keys
528 */
530 {
531 array = &so->arrayKeys[arrayidx - 1];
533
537 }
539 {
542
546 }
547
548 /*
549 * Both scan keys might have arrays, in which case we'll
550 * arbitrarily pass only one of the arrays. That won't
551 * matter, since _bt_compare_scankey_args is aware that two
552 * SEARCHARRAY scan keys mean that _bt_preprocess_array_keys
553 * failed to eliminate redundant arrays through array merging.
554 * _bt_compare_scankey_args just returns false when it sees
555 * this; it won't even try to examine either array.
556 */
557 }
558
561 {
562 /* Have all we need to determine redundancy */
564 {
565 /*
566 * New key is more restrictive, and so replaces old key...
567 */
570 {
574 }
575 else
576 {
577 /*
578 * ...unless we have to keep the old key because it's
579 * an array that rendered the new key redundant. We
580 * need to make sure that we don't throw away an array
581 * scan key. _bt_preprocess_array_keys_final expects
582 * us to keep all of the arrays that weren't already
583 * eliminated by _bt_preprocess_array_keys earlier on.
584 */
586 }
587 }
589 {
590 /* key == a && key == b, but a != b */
592 return;
593 }
594 /* else old key is more restrictive, keep it */
595 }
596 else
597 {
598 /*
599 * We can't determine which key is more restrictive. Push
600 * xform[j] directly to the output array, then set xform[j] to
601 * the new scan key.
602 *
603 * Note: We do things this way around so that our arrays are
604 * always in the same order as their corresponding scan keys.
605 * _bt_preprocess_array_keys_final expects this.
606 */
608
618 }
619 }
620 }
621
623
624 /*
625 * Now that we've built a temporary mapping from so->keyData[] (output
626 * scan keys) to arrayKeyData[] (our input scan keys), fix array->scan_key
627 * references. Also consolidate the so->orderProcs[] array such that it
628 * can be subscripted using so->keyData[]-wise offsets.
629 */
632
633 /*
634 * If there are remaining redundant inequality keys, we must make sure
635 * that each index attribute has no more than one required >/>= key, and
636 * no more than one required </<= key. Attributes that have one or more
637 * required = keys now must keep only one required key (the first = key).
638 */
641
642 /* Could pfree arrayKeyData/keyDataMap now, but not worth the cycles */
643}
static bool _bt_fix_scankey_strategy(ScanKey skey, int16 *indoption)
Definition nbtpreprocesskeys.c:668
static void _bt_unmark_keys(IndexScanDesc scan, int *keyDataMap)
Definition nbtpreprocesskeys.c:1543
static void _bt_mark_scankey_required(ScanKey skey)
Definition nbtpreprocesskeys.c:780
static ScanKey _bt_preprocess_array_keys(IndexScanDesc scan, int *new_numberOfKeys)
Definition nbtpreprocesskeys.c:1845
static void _bt_preprocess_array_keys_final(IndexScanDesc scan, int *keyDataMap)
Definition nbtpreprocesskeys.c:2225
static bool _bt_compare_scankey_args(IndexScanDesc scan, ScanKey op, ScanKey leftarg, ScanKey rightarg, BTArrayKeyInfo *array, FmgrInfo *orderproc, bool *result)
Definition nbtpreprocesskeys.c:870
Definition nbtpreprocesskeys.c:28
References _bt_compare_scankey_args(), _bt_fix_scankey_strategy(), _bt_mark_scankey_required(), _bt_preprocess_array_keys(), _bt_preprocess_array_keys_final(), _bt_unmark_keys(), Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTMaxStrategyNumber, elog, ERROR, fb(), i, IndexScanDescData::indexRelation, j, IndexScanDescData::keyData, MemoryContextAlloc(), IndexScanDescData::numberOfKeys, OidIsValid, IndexScanDescData::opaque, RelationData::rd_indoption, repalloc(), BTArrayKeyInfo::scan_key, ScanKeyData::sk_attno, SK_BT_SKIP, ScanKeyData::sk_flags, SK_SEARCHARRAY, SK_SEARCHNULL, ScanKeyData::sk_strategy, and unlikely.
Referenced by _bt_first().
◆ _bt_reorder_array_cmp()
Definition at line 1793 of file nbtpreprocesskeys.c.
1794{
1797
1799}
References a, b, fb(), and pg_cmp_s32().
Referenced by _bt_unmark_keys().
◆ _bt_saoparray_shrink()
|
static |
Definition at line 1135 of file nbtpreprocesskeys.c.
1137{
1141 cmpexact = 0,
1142 matchelem,
1143 new_nelems = 0;
1146
1149
1150 /*
1151 * _bt_binsrch_array_skey searches an array for the entry best matching a
1152 * datum of opclass input type for the index's attribute (on-disk type).
1153 * We can reuse the array's ORDER proc whenever the non-array scan key's
1154 * type is a match for the corresponding attribute's input opclass type.
1155 * Otherwise, we have to do another ORDER proc lookup so that our call to
1156 * _bt_binsrch_array_skey applies the correct comparator.
1157 *
1158 * Note: we have to support the convention that sk_subtype == InvalidOid
1159 * means the opclass input type; this is a hack to simplify life for
1160 * ScanKeyInit().
1161 */
1163 {
1164 RegProcedure cmp_proc;
1166
1167 /*
1168 * Need an ORDER proc lookup to detect redundancy/contradictoriness
1169 * with this pair of scankeys.
1170 *
1171 * Scalar scan key's argument will be passed to _bt_compare_array_skey
1172 * as its tupdatum/lefthand argument (rhs arg is for array elements).
1173 */
1179 BTORDER_PROC);
1181 {
1182 /* Can't make the comparison */
1183 *qual_ok = false; /* suppress compiler warnings */
1184 return false;
1185 }
1186
1187 /* We have all we need to determine redundancy/contradictoriness */
1190 }
1191
1193 NoMovementScanDirection,
1196
1198 {
1201 /* FALL THRU */
1204 matchelem++;
1205 /* Resize, keeping elements from the start of the array */
1207 break;
1210 {
1211 /* qual is unsatisfiable */
1212 new_nelems = 0;
1213 }
1214 else
1215 {
1216 /* Shift matching element to the start of the array, resize */
1218 new_nelems = 1;
1219 }
1220 break;
1223 /* FALL THRU */
1226 matchelem++;
1227 /* Shift matching elements to the start of the array, resize */
1231 break;
1232 default:
1235 break;
1236 }
1237
1240
1242 *qual_ok = new_nelems > 0;
1243
1244 return true;
1245}
int _bt_binsrch_array_skey(FmgrInfo *orderproc, bool cur_elem_trig, ScanDirection dir, Datum tupdatum, bool tupnull, BTArrayKeyInfo *array, ScanKey cur, int32 *set_elem_result)
Definition nbtreadpage.c:3415
References _bt_binsrch_array_skey(), Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTORDER_PROC, BTArrayKeyInfo::elem_values, elog, ERROR, fb(), fmgr_info(), get_opfamily_proc(), IndexScanDescData::indexRelation, InvalidOid, NoMovementScanDirection, BTArrayKeyInfo::num_elems, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, and SK_BT_SKIP.
Referenced by _bt_compare_array_scankey_args().
◆ _bt_setup_array_cmp()
|
static |
Definition at line 2652 of file nbtpreprocesskeys.c.
2654{
2657 RegProcedure cmp_proc;
2659
2662
2663 /*
2664 * If scankey operator is not a cross-type comparison, we can use the
2665 * cached comparison function; otherwise gotta look it up in the catalogs
2666 */
2667 if (elemtype == opcintype)
2668 {
2669 /* Set same-type ORDER procs for caller */
2673
2674 return;
2675 }
2676
2677 /*
2678 * Look up the appropriate cross-type comparison function in the opfamily.
2679 *
2680 * Use the opclass input type as the left hand arg type, and the array
2681 * element type as the right hand arg type (since binary searches use an
2682 * index tuple's attribute value to search for a matching array element).
2683 *
2684 * Note: it's possible that this would fail, if the opfamily is
2685 * incomplete, but only in cases where it's quite likely that _bt_first
2686 * would fail in just the same way (had we not failed before it could).
2687 */
2689 opcintype, elemtype, BTORDER_PROC);
2693 RelationGetRelationName(rel));
2694
2695 /* Set cross-type ORDER proc for caller */
2697
2698 /* Done if caller doesn't actually have an array they'll need to sort */
2700 return;
2701
2702 /*
2703 * Look up the appropriate same-type comparison function in the opfamily.
2704 *
2705 * Note: it's possible that this would fail, if the opfamily is
2706 * incomplete, but it seems quite unlikely that an opfamily would omit
2707 * non-cross-type comparison procs for any datatype that it supports at
2708 * all.
2709 */
2711 elemtype, elemtype, BTORDER_PROC);
2714 BTORDER_PROC, elemtype, elemtype,
2716
2717 /* Set same-type ORDER proc for caller */
2719}
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition indexam.c:917
References Assert, BTEqualStrategyNumber, BTORDER_PROC, elog, ERROR, fb(), fmgr_info_cxt(), get_opfamily_proc(), index_getprocinfo(), IndexScanDescData::indexRelation, OidIsValid, IndexScanDescData::opaque, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, and RelationGetRelationName.
Referenced by _bt_preprocess_array_keys(), and _bt_preprocess_array_keys_final().
◆ _bt_skiparray_shrink()
|
static |
Definition at line 1260 of file nbtpreprocesskeys.c.
1262{
1264
1266
1267 /*
1268 * Array's index attribute will be constrained by a strict operator/key.
1269 * Array must not "contain a NULL element" (i.e. the scan must not apply
1270 * "IS NULL" qual when it reaches the end of the index that stores NULLs).
1271 */
1273 *qual_ok = true;
1274
1275 /*
1276 * Consider if we should treat caller's scalar scan key as the skip
1277 * array's high_compare or low_compare.
1278 *
1279 * In general the current array element must either be a copy of a value
1280 * taken from an index tuple, or a derivative value generated by opclass's
1281 * skip support function. That way the scan can always safely assume that
1282 * it's okay to use the only-input-opclass-type proc from so->orderProcs[]
1283 * (they can be cross-type with SAOP arrays, but never with skip arrays).
1284 *
1285 * This approach is enabled by MINVAL/MAXVAL sentinel key markings, which
1286 * can be thought of as representing either the lowest or highest matching
1287 * array element (excluding the NULL element, where applicable, though as
1288 * just discussed it isn't applicable to this range skip array anyway).
1289 * Array keys marked MINVAL/MAXVAL never have a valid datum in their
1290 * sk_argument field. The scan directly applies the array's low_compare
1291 * key when it encounters MINVAL in the array key proper (just as it
1292 * applies high_compare when it sees MAXVAL set in the array key proper).
1293 * The scan must never use the array's so->orderProcs[] proc against
1294 * low_compare's/high_compare's sk_argument, either (so->orderProcs[] is
1295 * only intended to be used with rhs datums from the array proper/index).
1296 */
1298 {
1302 {
1303 /* replace existing high_compare with caller's key? */
1306 &test_result))
1307 return false; /* can't determine more restrictive key */
1308
1310 return true; /* no, just discard caller's key */
1311
1312 /* yes, replace existing high_compare with caller's key */
1313 }
1314
1315 /* caller's key becomes skip array's high_compare */
1317 break;
1321 {
1322 /* replace existing low_compare with caller's key? */
1325 &test_result))
1326 return false; /* can't determine more restrictive key */
1327
1329 return true; /* no, just discard caller's key */
1330
1331 /* yes, replace existing low_compare with caller's key */
1332 }
1333
1334 /* caller's key becomes skip array's low_compare */
1336 break;
1338 default:
1341 break;
1342 }
1343
1344 return true;
1345}
References _bt_compare_scankey_args(), Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, elog, ERROR, fb(), BTArrayKeyInfo::high_compare, BTArrayKeyInfo::low_compare, BTArrayKeyInfo::null_elem, and BTArrayKeyInfo::num_elems.
Referenced by _bt_compare_array_scankey_args().
◆ _bt_skiparray_strat_adjust()
|
static |
Definition at line 1382 of file nbtpreprocesskeys.c.
1384{
1387
1388 /*
1389 * Called last among all preprocessing steps, when the skip array's final
1390 * low_compare and high_compare have both been chosen
1391 */
1394
1396
1400
1404
1406}
static void _bt_skiparray_strat_increment(IndexScanDesc scan, ScanKey arraysk, BTArrayKeyInfo *array)
Definition nbtpreprocesskeys.c:1470
static void _bt_skiparray_strat_decrement(IndexScanDesc scan, ScanKey arraysk, BTArrayKeyInfo *array)
Definition nbtpreprocesskeys.c:1412
References _bt_skiparray_strat_decrement(), _bt_skiparray_strat_increment(), Assert, BTGreaterStrategyNumber, BTLessStrategyNumber, fb(), BTArrayKeyInfo::high_compare, BTArrayKeyInfo::low_compare, MemoryContextSwitchTo(), BTArrayKeyInfo::null_elem, BTArrayKeyInfo::num_elems, IndexScanDescData::opaque, SK_BT_SKIP, ScanKeyData::sk_strategy, and BTArrayKeyInfo::sksup.
Referenced by _bt_preprocess_array_keys_final().
◆ _bt_skiparray_strat_decrement()
|
static |
Definition at line 1412 of file nbtpreprocesskeys.c.
1414{
1418 leop;
1419 RegProcedure cmp_proc;
1422 new_sk_argument;
1425
1427
1428 /*
1429 * Only perform the transformation when the operator type matches the
1430 * index attribute's input opclass type
1431 */
1434 return;
1435
1436 /* Decrement, handling underflow by marking the qual unsatisfiable */
1439 {
1441
1443 return;
1444 }
1445
1446 /*
1447 * Look up <= operator (might fail), accounting for the fact that a
1448 * high_compare on a DESC column already had its strategy commuted
1449 */
1455 return;
1458 {
1459 /* Transform < high_compare key into <= key */
1463 }
1464}
References Assert, BTGreaterEqualStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, SkipSupportData::decrement, fb(), fmgr_info(), get_opcode(), get_opfamily_member(), BTArrayKeyInfo::high_compare, IndexScanDescData::indexRelation, InvalidOid, OidIsValid, IndexScanDescData::opaque, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, ScanKeyData::sk_argument, SK_BT_DESC, ScanKeyData::sk_flags, ScanKeyData::sk_func, ScanKeyData::sk_strategy, ScanKeyData::sk_subtype, and BTArrayKeyInfo::sksup.
Referenced by _bt_skiparray_strat_adjust().
◆ _bt_skiparray_strat_increment()
|
static |
Definition at line 1470 of file nbtpreprocesskeys.c.
1472{
1476 geop;
1477 RegProcedure cmp_proc;
1480 new_sk_argument;
1483
1485
1486 /*
1487 * Only perform the transformation when the operator type matches the
1488 * index attribute's input opclass type
1489 */
1492 return;
1493
1494 /* Increment, handling overflow by marking the qual unsatisfiable */
1497 {
1499
1501 return;
1502 }
1503
1504 /*
1505 * Look up >= operator (might fail), accounting for the fact that a
1506 * low_compare on a DESC column already had its strategy commuted
1507 */
1513 return;
1516 {
1517 /* Transform > low_compare key into >= key */
1521 }
1522}
References Assert, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, fb(), fmgr_info(), get_opcode(), get_opfamily_member(), SkipSupportData::increment, IndexScanDescData::indexRelation, InvalidOid, BTArrayKeyInfo::low_compare, OidIsValid, IndexScanDescData::opaque, RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, ScanKeyData::sk_argument, SK_BT_DESC, ScanKeyData::sk_flags, ScanKeyData::sk_func, ScanKeyData::sk_strategy, ScanKeyData::sk_subtype, and BTArrayKeyInfo::sksup.
Referenced by _bt_skiparray_strat_adjust().
◆ _bt_sort_array_elements()
|
static |
Definition at line 2732 of file nbtpreprocesskeys.c.
2734{
2735 BTSortArrayContext cxt;
2736
2737 if (nelems <= 1)
2738 return nelems; /* no work to do */
2739
2740 /* Sort the array elements */
2741 cxt.sortproc = sortproc;
2743 cxt.reverse = reverse;
2745 _bt_compare_array_elements, &cxt);
2746
2747 /* Now scan the sorted elements and remove duplicates */
2749 _bt_compare_array_elements, &cxt);
2750}
void qsort_arg(void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)
static size_t qunique_arg(void *array, size_t elements, size_t width, int(*compare)(const void *, const void *, void *), void *arg)
Definition qunique.h:46
References _bt_compare_array_elements(), BTSortArrayContext::collation, fb(), qsort_arg(), qunique_arg(), BTSortArrayContext::reverse, and BTSortArrayContext::sortproc.
Referenced by _bt_preprocess_array_keys().
◆ _bt_unmark_keys()
|
static |
Definition at line 1543 of file nbtpreprocesskeys.c.
1544{
1546 AttrNumber attno;
1549 nunmarked,
1550 nkept,
1551 firsti;
1553 unmarkKeys;
1557 haveReqForward,
1558 haveReqBackward;
1559
1560 /*
1561 * Do an initial pass over so->keyData[] that determines which keys to
1562 * keep as required. We expect so->keyData[] to still be in attribute
1563 * order when we're called (though we don't expect any particular order
1564 * among each attribute's keys).
1565 *
1566 * When both equality and inequality keys remain on a single attribute, we
1567 * *must* make sure that exactly one of the equalities remains required.
1568 * Any requiredness markings that we might leave on later keys/attributes
1569 * are predicated on there being required = keys on all prior columns.
1570 */
1572 nunmark = 0;
1573
1574 /* Set things up for first key's attribute */
1575 attno = so->keyData[0].sk_attno;
1576 firsti = 0;
1581 {
1583
1585 {
1586 /* Reset for next attribute */
1589
1593 }
1594
1595 /* Equalities get priority over inequalities */
1597 {
1598 /*
1599 * We already found the first "=" key for this attribute. We've
1600 * already decided that all its other keys will be unmarked.
1601 */
1604 nunmark++;
1605 continue;
1606 }
1609 {
1610 /*
1611 * Found the first "=" key for attno. All other attno keys will
1612 * be unmarked.
1613 */
1615
1618 {
1619 /* Unmark any prior inequality keys on attno after all */
1621 {
1623 nunmark++;
1624 }
1625 }
1626 continue;
1627 }
1628
1629 /* Deal with inequalities next */
1631 {
1633 continue;
1634 }
1636 {
1638 continue;
1639 }
1640
1641 /*
1642 * We have either a redundant inequality key that will be unmarked, or
1643 * we have a key that wasn't marked required in the first place
1644 */
1646 nunmark++;
1647 }
1648
1649 /* Should only be called when _bt_compare_scankey_args reported failure */
1651
1652 /*
1653 * Next, allocate temp arrays: one for required keys that'll remain
1654 * required, the other for all remaining keys
1655 */
1658 nunmarked = 0;
1659 nkept = 0;
1661 {
1664 }
1665
1666 /*
1667 * Next, copy the contents of so->keyData[] into the appropriate temp
1668 * array.
1669 *
1670 * Scans with = array keys need us to maintain invariants around the order
1671 * of so->orderProcs[] and so->arrayKeys[] relative to so->keyData[]. See
1672 * _bt_preprocess_array_keys_final for a full explanation.
1673 */
1675 {
1678
1680 {
1681 /*
1682 * Key gets to keep its original requiredness markings.
1683 *
1684 * Key will stay in its original position, unless we're going to
1685 * unmark an earlier key (in which case this key gets moved back).
1686 */
1688
1690 {
1694 }
1695
1696 nkept++;
1697 continue;
1698 }
1699
1700 /*
1701 * Key will be unmarked as needed, and moved to the end of the array,
1702 * next to other keys that will become (or always were) nonrequired
1703 */
1706
1708 {
1712 }
1713
1714 /*
1715 * Preprocessing only generates skip arrays when it knows that they'll
1716 * be the only required = key on the attr. We'll never unmark them.
1717 */
1719
1720 /*
1721 * Also shouldn't have to unmark an IS NULL or an IS NOT NULL key.
1722 * They aren't cross-type, so an incomplete opfamily can't matter.
1723 */
1726
1727 /* Clear requiredness flags on redundant key (and on any subkeys) */
1730 {
1732
1734 for (;;)
1735 {
1739 break;
1740 subkey++;
1741 }
1742 }
1743
1744 nunmarked++;
1745 }
1746
1747 /* Copy both temp arrays back into so->keyData[] to reorder */
1752
1753 /* Done with temp arrays */
1757
1758 /*
1759 * Now copy so->orderProcs[] temp entries needed by scans with = array
1760 * keys back (just like with the so->keyData[] temp arrays)
1761 */
1763 {
1767
1768 /* Also fix-up array->scan_key references */
1770 {
1772
1774 }
1775
1776 /*
1777 * Sort so->arrayKeys[] based on its new BTArrayKeyInfo.scan_key
1778 * offsets, so that its order matches so->keyData[] order as expected
1779 */
1781 _bt_reorder_array_cmp);
1782
1783 /* Done with temp arrays */
1786 }
1787}
static int _bt_reorder_array_cmp(const void *a, const void *b)
Definition nbtpreprocesskeys.c:1793
References _bt_reorder_array_cmp(), Assert, BTEqualStrategyNumber, DatumGetPointer(), fb(), i, j, IndexScanDescData::opaque, palloc(), palloc0(), pfree(), qsort, BTArrayKeyInfo::scan_key, ScanKeyData::sk_attno, SK_BT_REQBKWD, SK_BT_REQFWD, SK_BT_SKIP, SK_ISNULL, SK_ROW_END, SK_ROW_HEADER, SK_ROW_MEMBER, and SK_SEARCHNULL.
Referenced by _bt_preprocess_keys().
