Hi hackers, Attached is a series of patches which gradually reduce the time it takes to create GIN indexes. Most of the gains come from optimizing the trigram extraction code in pg_trgm. A few small optimizations apply to any GIN index operator class.
The changes are motivated by the time it takes to create GIN indexes on large production tables, especially, on columns with long strings. Even with multiple parallel maintenance workers I've seen this taking hours. For testing purposes I've used two different data sets: 1. The l_comment column of the TPC-H SF 10 lineitem table. l_comment contains relatively short strings with a minimum of 10, a maximum of 43 and an average of ~27 characters. 2. The plots from a collection of movies from Wikipedia. The plots are much longer than l_comment, with a minimum of 15, a maximum of 36,773 and an average of ~2,165 characters. The CSV file can be downloaded here [1]. Testing both cases is important because a big part of the trigram extraction is spent on removing duplicates. The longer the string, the more duplicates are usually encountered. The script I used for testing is attached. I ran CREATE INDEX three times and took the fastest run. I'm getting the following results on my i9-13950HX dev laptop in release build: Data set | Patched (ms) | Master (ms) | Speedup --------------------|--------------|--------------|---------- movies(plot) | 3,409 | 10,311 | 3.02x lineitem(l_comment) | 161,569 | 256,986 | 1.59x The attached patches do the following: - v1-0001-Inline-ginCompareAttEntries.patch: Inline ginCompareAttEntries() which is very frequently called by the GIN code. - v1-0002-Optimized-comparison-functions.patch: Use FunctionCallInvoke() instead of FunctionCall2Coll(). This saves a bunch of per-comparison setup code, such as calling InitFunctionCallInfoData(). - v1-0003-Use-sort_template.h.patch: Use sort_template.h instead of qsort(), to inline calls to the sort comparator. This is an interim step that is further improved on by patch 0006. - v1-0004-Avoid-dedup-and-sort-in-ginExtractEntries.patch ginExtractEntries() deduplicates and sorts the entries returned from the extract value function. In case of pg_trgm, that is completely redundant because the trigrams are already deduplicated and sorted. The current version of this patch is just to demonstrate the potential. We need to think about what we want here. Ideally, we would require the extraction function to provide the entries deduplicated and sorted. Alternatively, we could indicate to ginExtractEntries() if the entries are already deduplicated and sorted. If we don't want to alter the signature of the extract value function, we could e.g. use the MSB of the nentries argument. - v1-0005-Make-btint4cmp-branchless.patch: Removes branches from btint4cmp(), which is heavily called from the GIN code. This might as well have benefit in other parts of the code base. v1-0006-Use-radix-sort.patch: Replace the sort_template.h-based qsort() with radix sort. For the purpose of demonstrating the possible gains, I've only replaced the signed variant for now. I've also tried using simplehash.h for deduplicating followed by a sort_template.h-based sort. But that was slower. v1-0007-Faster-qunique-comparator.patch: qunique() doesn't require a full sort comparator (-1 = less, 0 = equal, 1 = greater) but only a equal/unequal comparator (e.g. 0 = equal and 1 = unequal). The same optimization can be done in plenty of other places in our code base. Likely, in most of them the gains are insignificant. v1-0008-Add-ASCII-fastpath-to-generate_trgm_only.patch: Typically lots of text is actually ASCII. Hence, we provide a fast path for this case which is exercised if the MSB of the current character is unset. With above changes, the majority of the runtime is now spent on inserting the trigrams into the GIN index via ginInsertBAEntry(). The code in master uses a red-black for further deduplication and sorting. Traversing the red-black tree and updating it is pretty slow. I haven't looked through all the code yet, but it seems to me that we would be better off replacing the red-black tree with a sort and/or a hash map. But I'll leave this as future work for now. [1] https://github.com/kiq005/movie-recommendation/raw/refs/heads/master/src/dataset/wiki_movie_plots_deduped.csv -- David Geier
From fc7bf3bd9c1bdf1336c233a796079556bb1dbf9d Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Fri, 14 Nov 2025 11:37:40 +0100 Subject: [PATCH v1 8/8] Add ASCII fastpath to generate_trgm_only() --- contrib/pg_trgm/trgm_op.c | 124 ++++++++++++++++++++------------------ 1 file changed, 65 insertions(+), 59 deletions(-) diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c index e07c553b1bd..42343bd1442 100644 --- a/contrib/pg_trgm/trgm_op.c +++ b/contrib/pg_trgm/trgm_op.c @@ -226,32 +226,6 @@ show_limit(PG_FUNCTION_ARGS) PG_RETURN_FLOAT4(similarity_threshold); } -/* - * Finds first word in string, returns pointer to the word, - * endword points to the character after word - */ -static char * -find_word(char *str, int lenstr, char **endword, int *charlen) -{ - char *beginword = str; - - while (beginword - str < lenstr && !ISWORDCHR(beginword)) - beginword += pg_mblen(beginword); - - if (beginword - str >= lenstr) - return NULL; - - *endword = beginword; - *charlen = 0; - while (*endword - str < lenstr && ISWORDCHR(*endword)) - { - *endword += pg_mblen(*endword); - (*charlen)++; - } - - return beginword; -} - /* * Reduce a trigram (three possibly multi-byte characters) to a trgm, * which is always exactly three bytes. If we have three single-byte @@ -337,58 +311,90 @@ make_trigrams(trgm *tptr, char *str, int bytelen, int charlen) static int generate_trgm_only(trgm *trg, char *str, int slen, TrgmBound *bounds) { - trgm *tptr; - char *buf; - int charlen, - bytelen; - char *bword, - *eword; + trgm *tptr = trg; + char *buf; if (slen + LPADDING + RPADDING < 3 || slen == 0) return 0; - tptr = trg; + buf = palloc_array(char, slen * pg_database_encoding_max_length() + 4 + 1); + memset(buf, ' ', LPADDING); - /* Allocate a buffer for case-folded, blank-padded words */ - buf = (char *) palloc(slen * pg_database_encoding_max_length() + 4); - - if (LPADDING > 0) + for (int i = 0; i < slen; ) { - *buf = ' '; - if (LPADDING > 1) - *(buf + 1) = ' '; - } + int num_bytes = LPADDING; + int num_chars = LPADDING; + char *word; - eword = str; - while ((bword = find_word(eword, slen - (eword - str), &eword, &charlen)) != NULL) - { + /* Extract next word */ + while (i < slen) + { + if ((str[i] & 0x80) == 0) /* Fast path for ASCII-only */ + { + if (isalnum(str[i])) + { #ifdef IGNORECASE - bword = str_tolower(bword, eword - bword, DEFAULT_COLLATION_OID); - bytelen = strlen(bword); + buf[num_bytes++] = pg_ascii_tolower(str[i++]); #else - bytelen = eword - bword; + buf[num_bytes++] = str[i++]; #endif + } + else + { + i++; + break; + } + } + else + { + const int mblen = pg_mblen(str + i); + Assert(mblen >= 2); /* Otherwise, it would be ASCII */ + + if (ISWORDCHR(str + i)) + { + memcpy(buf + num_bytes, str + i, mblen); + num_bytes += mblen; + i += mblen; + } + else + { + i += mblen; + break; + } + } + + num_chars++; + } - memcpy(buf + LPADDING, bword, bytelen); + if (num_chars > LPADDING) + { + memset(buf + num_bytes, ' ', RPADDING); + num_bytes += RPADDING; + num_chars += RPADDING; + word = buf; #ifdef IGNORECASE - pfree(bword); + if (num_chars != num_bytes) + { + word = str_tolower(buf, num_bytes, DEFAULT_COLLATION_OID); + num_bytes = strlen(word); /* String can get shorter from lower-casing */ + } #endif - buf[LPADDING + bytelen] = ' '; - buf[LPADDING + bytelen + 1] = ' '; + if (bounds) + bounds[tptr - trg] |= TRGM_BOUND_LEFT; + + tptr = make_trigrams(tptr, word, num_bytes, num_chars); + + if (bounds) + bounds[tptr - trg - 1] |= TRGM_BOUND_RIGHT; - /* Calculate trigrams marking their bounds if needed */ - if (bounds) - bounds[tptr - trg] |= TRGM_BOUND_LEFT; - tptr = make_trigrams(tptr, buf, bytelen + LPADDING + RPADDING, - charlen + LPADDING + RPADDING); - if (bounds) - bounds[tptr - trg - 1] |= TRGM_BOUND_RIGHT; + if (word != buf) + pfree(word); + } } pfree(buf); - return tptr - trg; } -- 2.51.0
From 4d101725a6101d723858d5b7561ff1cef123f671 Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Wed, 12 Nov 2025 14:27:13 +0100 Subject: [PATCH v1 7/8] Faster qunique() comparator --- contrib/pg_trgm/trgm_op.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c index 25ee049f352..e07c553b1bd 100644 --- a/contrib/pg_trgm/trgm_op.c +++ b/contrib/pg_trgm/trgm_op.c @@ -139,6 +139,14 @@ CMPTRGM_UNSIGNED(const void *a, const void *b) : CMPPCHAR_UNS(a, b, 2)); } +static inline int +CMPTRGM_EQ(const void *a, const void *b) +{ + char *aa = (char *)a; + char *bb = (char *)b; + return aa[0] != bb[0] || aa[1] != bb[1] || aa[2] != bb[2] ? 1 : 0; +} + /* * This gets called on the first call. It replaces the function pointer so * that subsequent calls are routed directly to the chosen implementation. @@ -482,15 +490,11 @@ generate_trgm(char *str, int slen) if (len > 1) { if (GetDefaultCharSignedness()) - { radix_sort_trigrams_signed((trgm *)GETARR(trg), len); - len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); - } else - { trigram_qsort_unsigned((void *) GETARR(trg), len, sizeof(trgm)); - len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_UNSIGNED); - } + + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_EQ); } SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len)); @@ -1038,15 +1042,11 @@ generate_wildcard_trgm(const char *str, int slen) if (len > 1) { if (GetDefaultCharSignedness()) - { radix_sort_trigrams_signed((trgm *)GETARR(trg), len); - len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); - } else - { trigram_qsort_unsigned((void *) GETARR(trg), len, sizeof(trgm)); - len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_UNSIGNED); - } + + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_EQ); } SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len)); -- 2.51.0
From 6148b4bbc702eb4ce89994f3aa4790def50ed0c5 Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Tue, 11 Nov 2025 13:18:59 +0100 Subject: [PATCH v1 6/8] Use radix sort --- contrib/pg_trgm/trgm_op.c | 64 +++++++++++++++++++++++++++++++++------ 1 file changed, 54 insertions(+), 10 deletions(-) diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c index 875065a4670..25ee049f352 100644 --- a/contrib/pg_trgm/trgm_op.c +++ b/contrib/pg_trgm/trgm_op.c @@ -155,14 +155,6 @@ CMPTRGM_CHOOSE(const void *a, const void *b) } /* Define our specialized sort function name */ -#define ST_SORT trigram_qsort_signed -#define ST_ELEMENT_TYPE_VOID -#define ST_COMPARE(a, b) CMPTRGM_SIGNED(a, b) -#define ST_SCOPE static -#define ST_DEFINE -#define ST_DECLARE -#include "lib/sort_template.h" - #define ST_SORT trigram_qsort_unsigned #define ST_ELEMENT_TYPE_VOID #define ST_COMPARE(a, b) CMPTRGM_UNSIGNED(a, b) @@ -392,6 +384,58 @@ generate_trgm_only(trgm *trg, char *str, int slen, TrgmBound *bounds) return tptr - trg; } +/* + * Needed to properly handle negative numbers in case char is signed. + */ +static inline unsigned char FlipSign(char x) +{ + return x^0x80; +} + +static void radix_sort_trigrams_signed(trgm *trg, int count) +{ + trgm *buffer = palloc_array(trgm, count); + trgm *starts[256]; + trgm *from = trg; + trgm *to = buffer; + int freqs[3][256]; + + /* + * Compute frequencies to partition the buffer. + */ + memset(freqs, 0, sizeof(freqs)); + + for (int i=0; i<count; i++) + for (int j=0; j<3; j++) + freqs[j][FlipSign(trg[i][j])]++; + + /* + * Do the sorting. Start with last character because that's the is "LSB" + * in a trigram. Avoid unnecessary copies by ping-ponging between the buffers. + */ + for (int i=2; i>=0; i--) + { + trgm *old_from = from; + trgm *next = to; + + for (int j=0; j<256; j++) + { + starts[j] = next; + next += freqs[i][j]; + } + + for (int j=0; j<count; j++) + memcpy(starts[FlipSign(from[j][i])]++, from[j], sizeof(trgm)); + + from = to; + to = old_from; + } + + Assert(to == buffer); + memcpy(trg, buffer, sizeof(trgm) * count); + pfree(buffer); +} + /* * Guard against possible overflow in the palloc requests below. (We * don't worry about the additive constants, since palloc can detect @@ -439,7 +483,7 @@ generate_trgm(char *str, int slen) { if (GetDefaultCharSignedness()) { - trigram_qsort_signed((void *) GETARR(trg), len, sizeof(trgm)); + radix_sort_trigrams_signed((trgm *)GETARR(trg), len); len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); } else @@ -995,7 +1039,7 @@ generate_wildcard_trgm(const char *str, int slen) { if (GetDefaultCharSignedness()) { - trigram_qsort_signed((void *) GETARR(trg), len, sizeof(trgm)); + radix_sort_trigrams_signed((trgm *)GETARR(trg), len); len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); } else -- 2.51.0
From 915bd326de5ebde4149093d52fff9c710e557de2 Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Mon, 10 Nov 2025 15:40:11 +0100 Subject: [PATCH v1 5/8] Make btint4cmp() branchless --- src/backend/access/nbtree/nbtcompare.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/backend/access/nbtree/nbtcompare.c b/src/backend/access/nbtree/nbtcompare.c index bffc4b7709c..5ae27c22621 100644 --- a/src/backend/access/nbtree/nbtcompare.c +++ b/src/backend/access/nbtree/nbtcompare.c @@ -60,6 +60,7 @@ #include "utils/fmgrprotos.h" #include "utils/skipsupport.h" #include "utils/sortsupport.h" +#include "common/int.h" #ifdef STRESS_SORT_INT_MIN #define A_LESS_THAN_B INT_MIN @@ -202,12 +203,7 @@ btint4cmp(PG_FUNCTION_ARGS) int32 a = PG_GETARG_INT32(0); int32 b = PG_GETARG_INT32(1); - if (a > b) - PG_RETURN_INT32(A_GREATER_THAN_B); - else if (a == b) - PG_RETURN_INT32(0); - else - PG_RETURN_INT32(A_LESS_THAN_B); + PG_RETURN_INT32(pg_cmp_s32(a, b)); } Datum -- 2.51.0
From e91198730d10d301857b1ef38670f506fc0749ca Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Mon, 10 Nov 2025 14:40:37 +0100 Subject: [PATCH v1 4/8] Avoid dedup and sort in ginExtractEntries --- src/backend/access/gin/ginutil.c | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index f4139effd6e..9187264dbdc 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -498,13 +498,6 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, return entries; } - /* - * If the extractValueFn didn't create a nullFlags array, create one, - * assuming that everything's non-null. - */ - if (nullFlags == NULL) - nullFlags = (bool *) palloc0(*nentries * sizeof(bool)); - /* * If there's more than one key, sort and unique-ify. * @@ -512,8 +505,8 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, * pretty bad too. For small numbers of keys it'd likely be better to use * a simple insertion sort. */ - if (*nentries > 1) - { + if (*nentries > 1 && nullFlags != NULL) + { keyEntryData *keydata; cmpEntriesArg arg; @@ -564,9 +557,13 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, /* * Create GinNullCategory representation from nullFlags. */ - *categories = (GinNullCategory *) palloc0(*nentries * sizeof(GinNullCategory)); - for (i = 0; i < *nentries; i++) - (*categories)[i] = (nullFlags[i] ? GIN_CAT_NULL_KEY : GIN_CAT_NORM_KEY); + StaticAssertStmt(GIN_CAT_NORM_KEY == 0, "Assuming GIN_CAT_NORM_KEY is 0"); + *categories = palloc0_array(GinNullCategory, *nentries); + + if (nullFlags != NULL) + for (i = 0; i < *nentries; i++) + if (nullFlags[i]) + (*categories)[i] = GIN_CAT_NULL_KEY; return entries; } -- 2.51.0
From 5a5b3b955fffac4baf2ea1367914ce87a6f8bf5a Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Mon, 10 Nov 2025 13:35:11 +0100 Subject: [PATCH v1 3/8] Use sort_template.h --- contrib/pg_trgm/trgm_op.c | 49 ++++++++++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 11 deletions(-) diff --git a/contrib/pg_trgm/trgm_op.c b/contrib/pg_trgm/trgm_op.c index 81182a15e07..875065a4670 100644 --- a/contrib/pg_trgm/trgm_op.c +++ b/contrib/pg_trgm/trgm_op.c @@ -154,6 +154,23 @@ CMPTRGM_CHOOSE(const void *a, const void *b) return CMPTRGM(a, b); } +/* Define our specialized sort function name */ +#define ST_SORT trigram_qsort_signed +#define ST_ELEMENT_TYPE_VOID +#define ST_COMPARE(a, b) CMPTRGM_SIGNED(a, b) +#define ST_SCOPE static +#define ST_DEFINE +#define ST_DECLARE +#include "lib/sort_template.h" + +#define ST_SORT trigram_qsort_unsigned +#define ST_ELEMENT_TYPE_VOID +#define ST_COMPARE(a, b) CMPTRGM_UNSIGNED(a, b) +#define ST_SCOPE static +#define ST_DEFINE +#define ST_DECLARE +#include "lib/sort_template.h" + /* * Deprecated function. * Use "pg_trgm.similarity_threshold" GUC variable instead of this function. @@ -209,12 +226,6 @@ show_limit(PG_FUNCTION_ARGS) PG_RETURN_FLOAT4(similarity_threshold); } -static int -comp_trgm(const void *a, const void *b) -{ - return CMPTRGM(a, b); -} - /* * Finds first word in string, returns pointer to the word, * endword points to the character after word @@ -426,12 +437,20 @@ generate_trgm(char *str, int slen) */ if (len > 1) { - qsort(GETARR(trg), len, sizeof(trgm), comp_trgm); - len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm); + if (GetDefaultCharSignedness()) + { + trigram_qsort_signed((void *) GETARR(trg), len, sizeof(trgm)); + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); + } + else + { + trigram_qsort_unsigned((void *) GETARR(trg), len, sizeof(trgm)); + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_UNSIGNED); + } } SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len)); - + return trg; } @@ -974,8 +993,16 @@ generate_wildcard_trgm(const char *str, int slen) */ if (len > 1) { - qsort(GETARR(trg), len, sizeof(trgm), comp_trgm); - len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm); + if (GetDefaultCharSignedness()) + { + trigram_qsort_signed((void *) GETARR(trg), len, sizeof(trgm)); + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_SIGNED); + } + else + { + trigram_qsort_unsigned((void *) GETARR(trg), len, sizeof(trgm)); + len = qunique(GETARR(trg), len, sizeof(trgm), CMPTRGM_UNSIGNED); + } } SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len)); -- 2.51.0
From eb7fe3763b31d30d48ebbd4934085fe70315249a Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Mon, 10 Nov 2025 13:35:01 +0100 Subject: [PATCH v1 2/8] Optimized comparison functions --- src/backend/access/gin/ginutil.c | 19 ++++++++++++------- src/include/access/gin_private.h | 19 +++++++++++++++---- 2 files changed, 27 insertions(+), 11 deletions(-) diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index d205093e21d..f4139effd6e 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -114,6 +114,7 @@ initGinState(GinState *state, Relation index) for (i = 0; i < origTupdesc->natts; i++) { Form_pg_attribute attr = TupleDescAttr(origTupdesc, i); + FunctionCallInfoBaseData *fci = &state->compareFnCallInfo[i].fcinfo; if (state->oneCol) state->tupdesc[i] = state->origTupdesc; @@ -222,6 +223,10 @@ initGinState(GinState *state, Relation index) state->supportCollation[i] = index->rd_indcollation[i]; else state->supportCollation[i] = DEFAULT_COLLATION_OID; + + InitFunctionCallInfoData(*fci, &state->compareFn[i], 2, state->supportCollation[i], NULL, NULL); + fci->args[0].isnull = false; + fci->args[1].isnull = false; } } @@ -402,8 +407,7 @@ typedef struct typedef struct { - FmgrInfo *cmpDatumFunc; - Oid collation; + FunctionCallInfoBaseData *cmpFuncInfo; bool haveDups; } cmpEntriesArg; @@ -425,9 +429,11 @@ cmpEntries(const void *a, const void *b, void *arg) else if (bb->isnull) res = -1; /* not-NULL "<" NULL */ else - res = DatumGetInt32(FunctionCall2Coll(data->cmpDatumFunc, - data->collation, - aa->datum, bb->datum)); + { + data->cmpFuncInfo->args[0].value = aa->datum; + data->cmpFuncInfo->args[1].value = bb->datum; + res = DatumGetInt32(FunctionCallInvoke(data->cmpFuncInfo)); + } /* * Detect if we have any duplicates. If there are equal keys, qsort must @@ -518,8 +524,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, keydata[i].isnull = nullFlags[i]; } - arg.cmpDatumFunc = &ginstate->compareFn[attnum - 1]; - arg.collation = ginstate->supportCollation[attnum - 1]; + arg.cmpFuncInfo = &ginstate->compareFnCallInfo[attnum - 1].fcinfo; arg.haveDups = false; qsort_arg(keydata, *nentries, sizeof(keyEntryData), cmpEntries, &arg); diff --git a/src/include/access/gin_private.h b/src/include/access/gin_private.h index e155045ce8a..7cf19c8a5dc 100644 --- a/src/include/access/gin_private.h +++ b/src/include/access/gin_private.h @@ -51,6 +51,11 @@ typedef struct GinOptions #define GIN_SHARE BUFFER_LOCK_SHARE #define GIN_EXCLUSIVE BUFFER_LOCK_EXCLUSIVE +typedef union CompareFuncCallInfoData +{ + FunctionCallInfoBaseData fcinfo; + char fcinfo_data[SizeForFunctionCallInfo(2)]; +} CompareFuncCallInfoData; /* * GinState: working data structure describing the index being worked on @@ -77,6 +82,10 @@ typedef struct GinState /* * Per-index-column opclass support functions */ + + + CompareFuncCallInfoData compareFnCallInfo[INDEX_MAX_KEYS]; + FmgrInfo compareFn[INDEX_MAX_KEYS]; FmgrInfo extractValueFn[INDEX_MAX_KEYS]; FmgrInfo extractQueryFn[INDEX_MAX_KEYS]; @@ -504,6 +513,8 @@ ginCompareEntries(GinState *ginstate, OffsetNumber attnum, Datum a, GinNullCategory categorya, Datum b, GinNullCategory categoryb) { + FunctionCallInfoBaseData *fci; + /* if not of same null category, sort by that first */ if (categorya != categoryb) return (categorya < categoryb) ? -1 : 1; @@ -512,10 +523,10 @@ ginCompareEntries(GinState *ginstate, OffsetNumber attnum, if (categorya != GIN_CAT_NORM_KEY) return 0; - /* both not null, so safe to call the compareFn */ - return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1], - ginstate->supportCollation[attnum - 1], - a, b)); + fci = &ginstate->compareFnCallInfo[attnum - 1].fcinfo; + fci->args[0].value = a; + fci->args[1].value = b; + return DatumGetInt32(FunctionCallInvoke(fci)); } /* -- 2.51.0
From a484e7c69bec62474b041eb4e533601e4883dab3 Mon Sep 17 00:00:00 2001 From: David Geier <[email protected]> Date: Thu, 6 Nov 2025 09:42:27 +0100 Subject: [PATCH v1 1/8] Inline ginCompareAttEntries --- src/backend/access/gin/ginutil.c | 38 --------------------------- src/include/access/gin_private.h | 44 +++++++++++++++++++++++++++----- 2 files changed, 38 insertions(+), 44 deletions(-) diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c index a546cac18d3..d205093e21d 100644 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@ -387,44 +387,6 @@ GinInitMetabuffer(Buffer b) ((char *) metadata + sizeof(GinMetaPageData)) - (char *) page; } -/* - * Compare two keys of the same index column - */ -int -ginCompareEntries(GinState *ginstate, OffsetNumber attnum, - Datum a, GinNullCategory categorya, - Datum b, GinNullCategory categoryb) -{ - /* if not of same null category, sort by that first */ - if (categorya != categoryb) - return (categorya < categoryb) ? -1 : 1; - - /* all null items in same category are equal */ - if (categorya != GIN_CAT_NORM_KEY) - return 0; - - /* both not null, so safe to call the compareFn */ - return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1], - ginstate->supportCollation[attnum - 1], - a, b)); -} - -/* - * Compare two keys of possibly different index columns - */ -int -ginCompareAttEntries(GinState *ginstate, - OffsetNumber attnuma, Datum a, GinNullCategory categorya, - OffsetNumber attnumb, Datum b, GinNullCategory categoryb) -{ - /* attribute number is the first sort key */ - if (attnuma != attnumb) - return (attnuma < attnumb) ? -1 : 1; - - return ginCompareEntries(ginstate, attnuma, a, categorya, b, categoryb); -} - - /* * Support for sorting key datums in ginExtractEntries * diff --git a/src/include/access/gin_private.h b/src/include/access/gin_private.h index b33f7cec5b4..e155045ce8a 100644 --- a/src/include/access/gin_private.h +++ b/src/include/access/gin_private.h @@ -97,12 +97,6 @@ extern Buffer GinNewBuffer(Relation index); extern void GinInitBuffer(Buffer b, uint32 f); extern void GinInitPage(Page page, uint32 f, Size pageSize); extern void GinInitMetabuffer(Buffer b); -extern int ginCompareEntries(GinState *ginstate, OffsetNumber attnum, - Datum a, GinNullCategory categorya, - Datum b, GinNullCategory categoryb); -extern int ginCompareAttEntries(GinState *ginstate, - OffsetNumber attnuma, Datum a, GinNullCategory categorya, - OffsetNumber attnumb, Datum b, GinNullCategory categoryb); extern Datum *ginExtractEntries(GinState *ginstate, OffsetNumber attnum, Datum value, bool isNull, int32 *nentries, GinNullCategory **categories); @@ -502,6 +496,44 @@ ginCompareItemPointers(ItemPointer a, ItemPointer b) return pg_cmp_u64(ia, ib); } +/* + * Compare two keys of the same index column + */ +static inline int +ginCompareEntries(GinState *ginstate, OffsetNumber attnum, + Datum a, GinNullCategory categorya, + Datum b, GinNullCategory categoryb) +{ + /* if not of same null category, sort by that first */ + if (categorya != categoryb) + return (categorya < categoryb) ? -1 : 1; + + /* all null items in same category are equal */ + if (categorya != GIN_CAT_NORM_KEY) + return 0; + + /* both not null, so safe to call the compareFn */ + return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1], + ginstate->supportCollation[attnum - 1], + a, b)); +} + +/* + * Compare two keys of possibly different index columns + */ +static inline int +ginCompareAttEntries(GinState *ginstate, + OffsetNumber attnuma, Datum a, GinNullCategory categorya, + OffsetNumber attnumb, Datum b, GinNullCategory categoryb) +{ + /* attribute number is the first sort key */ + if (attnuma != attnumb) + return (attnuma < attnumb) ? -1 : 1; + + return ginCompareEntries(ginstate, attnuma, a, categorya, b, categoryb); + +} + extern int ginTraverseLock(Buffer buffer, bool searchMode); #endif /* GIN_PRIVATE_H */ -- 2.51.0
test_gin_optimizations.sql
Description: application/sql
