From 3de2f0cbe238c3fbbceca1e3a9ed3c205870a6dd Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Fri, 10 Feb 2023 16:07:57 +0100 Subject: [PATCH 1/6] Support SK_SEARCHARRAY in BRIN minmax Set "amsearcharray=true" for BRIN, and extend the minmax opclass to handle both scalar values and arrays. This allows handling conditions ... WHERE a IN (1, 2, 43, 2132, 134) ... WHERE a = ANY(ARRAY[34, 45, -1, 234]) ... WHERE a <= ANY(ARRAY[4938, 282, 2934]) more efficiently - until now we simply built the bitmap for each scalar value, so we walked the BRIN index many times. Which may be quite expensive for indexes with many ranges (large tables and/or low pages_per_range). There's a couple problems / open questions / TODO items: - The other opclasses don't handle SK_SEARCHARRAY yet. - The array is always searched linearly, so this may be costly for large arrays (with many elements). - The array is deconstructed again for each range. We should reuse this, somehow. --- src/backend/access/brin/brin.c | 2 +- src/backend/access/brin/brin_minmax.c | 177 ++++++++++++++++++++------ 2 files changed, 140 insertions(+), 39 deletions(-) diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c index de1427a1e0..a600f37c15 100644 --- a/src/backend/access/brin/brin.c +++ b/src/backend/access/brin/brin.c @@ -101,7 +101,7 @@ brinhandler(PG_FUNCTION_ARGS) amroutine->amcanunique = false; amroutine->amcanmulticol = true; amroutine->amoptionalkey = true; - amroutine->amsearcharray = false; + amroutine->amsearcharray = true; amroutine->amsearchnulls = true; amroutine->amstorage = true; amroutine->amclusterable = false; diff --git a/src/backend/access/brin/brin_minmax.c b/src/backend/access/brin/brin_minmax.c index 2431591be6..c054d8ff42 100644 --- a/src/backend/access/brin/brin_minmax.c +++ b/src/backend/access/brin/brin_minmax.c @@ -16,6 +16,7 @@ #include "access/stratnum.h" #include "catalog/pg_amop.h" #include "catalog/pg_type.h" +#include "utils/array.h" #include "utils/builtins.h" #include "utils/datum.h" #include "utils/lsyscache.h" @@ -157,46 +158,146 @@ brin_minmax_consistent(PG_FUNCTION_ARGS) attno = key->sk_attno; subtype = key->sk_subtype; value = key->sk_argument; - switch (key->sk_strategy) + + /* + * For regular (scalar) scan keys, we simply compare the value to the + * range min/max values, and we're done. For SK_SEARCHARRAY keys we + * need to deparse the array and loop through the values. + */ + if (likely(!(key->sk_flags & SK_SEARCHARRAY))) { - case BTLessStrategyNumber: - case BTLessEqualStrategyNumber: - finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, - key->sk_strategy); - matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], - value); - break; - case BTEqualStrategyNumber: - - /* - * In the equality case (WHERE col = someval), we want to return - * the current page range if the minimum value in the range <= - * scan key, and the maximum value >= scan key. - */ - finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, - BTLessEqualStrategyNumber); - matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], - value); - if (!DatumGetBool(matches)) + switch (key->sk_strategy) + { + case BTLessStrategyNumber: + case BTLessEqualStrategyNumber: + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], + value); + break; + case BTEqualStrategyNumber: + + /* + * In the equality case (WHERE col = someval), we want to return + * the current page range if the minimum value in the range <= + * scan key, and the maximum value >= scan key. + */ + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + BTLessEqualStrategyNumber); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], + value); + if (!DatumGetBool(matches)) + break; + /* max() >= scankey */ + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + BTGreaterEqualStrategyNumber); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], + value); + break; + case BTGreaterEqualStrategyNumber: + case BTGreaterStrategyNumber: + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], + value); + break; + default: + /* shouldn't happen */ + elog(ERROR, "invalid strategy number %d", key->sk_strategy); + matches = 0; + break; + } + } + else + { + ArrayType *arrayval; + int16 elmlen; + bool elmbyval; + char elmalign; + int num_elems; + Datum *elem_values; + bool *elem_nulls; + + arrayval = DatumGetArrayTypeP(key->sk_argument); + + get_typlenbyvalalign(ARR_ELEMTYPE(arrayval), + &elmlen, &elmbyval, &elmalign); + + deconstruct_array(arrayval, + ARR_ELEMTYPE(arrayval), + elmlen, elmbyval, elmalign, + &elem_values, &elem_nulls, &num_elems); + + switch (key->sk_strategy) + { + case BTLessStrategyNumber: + case BTLessEqualStrategyNumber: + + for (int j = 0; j < num_elems; j++) + { + Datum val = elem_values[j]; + + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], + val); + + if (DatumGetBool(matches)) + break; + } + break; + case BTEqualStrategyNumber: + + /* + * In the equality case (WHERE col = someval), we want to return + * the current page range if the minimum value in the range <= + * scan key, and the maximum value >= scan key. + * + * XXX For any of the array values. + */ + for (int j = 0; j < num_elems; j++) + { + Datum val = elem_values[j]; + + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + BTLessEqualStrategyNumber); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[0], + val); + if (!DatumGetBool(matches)) + continue; + + /* max() >= scankey */ + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + BTGreaterEqualStrategyNumber); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], + val); + + if (DatumGetBool(matches)) + break; + } + break; + case BTGreaterEqualStrategyNumber: + case BTGreaterStrategyNumber: + + for (int j = 0; j < num_elems; j++) + { + Datum val = elem_values[j]; + + finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], + val); + + if (DatumGetBool(matches)) + break; + } + break; + default: + /* shouldn't happen */ + elog(ERROR, "invalid strategy number %d", key->sk_strategy); + matches = 0; break; - /* max() >= scankey */ - finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, - BTGreaterEqualStrategyNumber); - matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], - value); - break; - case BTGreaterEqualStrategyNumber: - case BTGreaterStrategyNumber: - finfo = minmax_get_strategy_procinfo(bdesc, attno, subtype, - key->sk_strategy); - matches = FunctionCall2Coll(finfo, colloid, column->bv_values[1], - value); - break; - default: - /* shouldn't happen */ - elog(ERROR, "invalid strategy number %d", key->sk_strategy); - matches = 0; - break; + } } PG_RETURN_DATUM(matches); -- 2.39.1