LCOV - code coverage report
Current view: top level - src/backend/utils/adt - tsgistidx.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 262 336 78.0 %
Date: 2023-12-11 16:10:55 Functions: 19 23 82.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * tsgistidx.c
       4             :  *    GiST support functions for tsvector_ops
       5             :  *
       6             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/adt/tsgistidx.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include "access/gist.h"
      18             : #include "access/heaptoast.h"
      19             : #include "access/reloptions.h"
      20             : #include "lib/qunique.h"
      21             : #include "port/pg_bitutils.h"
      22             : #include "tsearch/ts_utils.h"
      23             : #include "utils/builtins.h"
      24             : #include "utils/pg_crc.h"
      25             : 
      26             : 
      27             : /* tsvector_ops opclass options */
      28             : typedef struct
      29             : {
      30             :     int32       vl_len_;        /* varlena header (do not touch directly!) */
      31             :     int         siglen;         /* signature length */
      32             : } GistTsVectorOptions;
      33             : 
      34             : #define SIGLEN_DEFAULT  (31 * 4)
      35             : #define SIGLEN_MAX      GISTMaxIndexKeySize
      36             : #define GET_SIGLEN()    (PG_HAS_OPCLASS_OPTIONS() ? \
      37             :                          ((GistTsVectorOptions *) PG_GET_OPCLASS_OPTIONS())->siglen : \
      38             :                          SIGLEN_DEFAULT)
      39             : 
      40             : #define SIGLENBIT(siglen) ((siglen) * BITS_PER_BYTE)
      41             : 
      42             : typedef char *BITVECP;
      43             : 
      44             : #define LOOPBYTE(siglen) \
      45             :             for (i = 0; i < siglen; i++)
      46             : 
      47             : #define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITS_PER_BYTE ) ) )
      48             : #define GETBITBYTE(x,i) ( ((char)(x)) >> (i) & 0x01 )
      49             : #define CLRBIT(x,i)   GETBYTE(x,i) &= ~( 0x01 << ( (i) % BITS_PER_BYTE ) )
      50             : #define SETBIT(x,i)   GETBYTE(x,i) |=  ( 0x01 << ( (i) % BITS_PER_BYTE ) )
      51             : #define GETBIT(x,i) ( (GETBYTE(x,i) >> ( (i) % BITS_PER_BYTE )) & 0x01 )
      52             : 
      53             : #define HASHVAL(val, siglen) (((unsigned int)(val)) % SIGLENBIT(siglen))
      54             : #define HASH(sign, val, siglen) SETBIT((sign), HASHVAL(val, siglen))
      55             : 
      56             : #define GETENTRY(vec,pos) ((SignTSVector *) DatumGetPointer((vec)->vector[(pos)].key))
      57             : 
      58             : /*
      59             :  * type of GiST index key
      60             :  */
      61             : 
      62             : typedef struct
      63             : {
      64             :     int32       vl_len_;        /* varlena header (do not touch directly!) */
      65             :     int32       flag;
      66             :     char        data[FLEXIBLE_ARRAY_MEMBER];
      67             : } SignTSVector;
      68             : 
      69             : #define ARRKEY      0x01
      70             : #define SIGNKEY     0x02
      71             : #define ALLISTRUE   0x04
      72             : 
      73             : #define ISARRKEY(x) ( ((SignTSVector*)(x))->flag & ARRKEY )
      74             : #define ISSIGNKEY(x)    ( ((SignTSVector*)(x))->flag & SIGNKEY )
      75             : #define ISALLTRUE(x)    ( ((SignTSVector*)(x))->flag & ALLISTRUE )
      76             : 
      77             : #define GTHDRSIZE   ( VARHDRSZ + sizeof(int32) )
      78             : #define CALCGTSIZE(flag, len) ( GTHDRSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(int32)) : (((flag) & ALLISTRUE) ? 0 : (len)) ) )
      79             : 
      80             : #define GETSIGN(x)  ( (BITVECP)( (char*)(x)+GTHDRSIZE ) )
      81             : #define GETSIGLEN(x)( VARSIZE(x) - GTHDRSIZE )
      82             : #define GETARR(x)   ( (int32*)( (char*)(x)+GTHDRSIZE ) )
      83             : #define ARRNELEM(x) ( ( VARSIZE(x) - GTHDRSIZE )/sizeof(int32) )
      84             : 
      85             : static int32 sizebitvec(BITVECP sign, int siglen);
      86             : 
      87             : Datum
      88           0 : gtsvectorin(PG_FUNCTION_ARGS)
      89             : {
      90             :     /* There's no need to support input of gtsvectors */
      91           0 :     ereport(ERROR,
      92             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      93             :              errmsg("cannot accept a value of type %s", "gtsvector")));
      94             : 
      95             :     PG_RETURN_VOID();           /* keep compiler quiet */
      96             : }
      97             : 
      98             : #define SINGOUTSTR  "%d true bits, %d false bits"
      99             : #define ARROUTSTR   "%d unique words"
     100             : #define EXTRALEN    ( 2*13 )
     101             : 
     102             : static int  outbuf_maxlen = 0;
     103             : 
     104             : Datum
     105           0 : gtsvectorout(PG_FUNCTION_ARGS)
     106             : {
     107           0 :     SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
     108             :     char       *outbuf;
     109             : 
     110           0 :     if (outbuf_maxlen == 0)
     111           0 :         outbuf_maxlen = 2 * EXTRALEN + Max(strlen(SINGOUTSTR), strlen(ARROUTSTR)) + 1;
     112           0 :     outbuf = palloc(outbuf_maxlen);
     113             : 
     114           0 :     if (ISARRKEY(key))
     115           0 :         sprintf(outbuf, ARROUTSTR, (int) ARRNELEM(key));
     116             :     else
     117             :     {
     118           0 :         if (ISALLTRUE(key))
     119           0 :             sprintf(outbuf, "all true bits");
     120             :         else
     121             :         {
     122           0 :             int         siglen = GETSIGLEN(key);
     123           0 :             int         cnttrue = sizebitvec(GETSIGN(key), siglen);
     124             : 
     125           0 :             sprintf(outbuf, SINGOUTSTR, cnttrue, (int) SIGLENBIT(siglen) - cnttrue);
     126             :         }
     127             :     }
     128             : 
     129           0 :     PG_FREE_IF_COPY(key, 0);
     130           0 :     PG_RETURN_POINTER(outbuf);
     131             : }
     132             : 
     133             : static int
     134     3626136 : compareint(const void *va, const void *vb)
     135             : {
     136     3626136 :     int32       a = *((const int32 *) va);
     137     3626136 :     int32       b = *((const int32 *) vb);
     138             : 
     139     3626136 :     if (a == b)
     140           0 :         return 0;
     141     3626136 :     return (a > b) ? 1 : -1;
     142             : }
     143             : 
     144             : static void
     145       75128 : makesign(BITVECP sign, SignTSVector *a, int siglen)
     146             : {
     147             :     int32       k,
     148       75128 :                 len = ARRNELEM(a);
     149       75128 :     int32      *ptr = GETARR(a);
     150             : 
     151       75128 :     MemSet(sign, 0, siglen);
     152     4189952 :     for (k = 0; k < len; k++)
     153     4114824 :         HASH(sign, ptr[k], siglen);
     154       75128 : }
     155             : 
     156             : static SignTSVector *
     157       19428 : gtsvector_alloc(int flag, int len, BITVECP sign)
     158             : {
     159       19428 :     int         size = CALCGTSIZE(flag, len);
     160       19428 :     SignTSVector *res = palloc(size);
     161             : 
     162       19428 :     SET_VARSIZE(res, size);
     163       19428 :     res->flag = flag;
     164             : 
     165       19428 :     if ((flag & (SIGNKEY | ALLISTRUE)) == SIGNKEY && sign)
     166         816 :         memcpy(GETSIGN(res), sign, len);
     167             : 
     168       19428 :     return res;
     169             : }
     170             : 
     171             : 
     172             : Datum
     173       15714 : gtsvector_compress(PG_FUNCTION_ARGS)
     174             : {
     175       15714 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     176       15714 :     int         siglen = GET_SIGLEN();
     177       15714 :     GISTENTRY  *retval = entry;
     178             : 
     179       15714 :     if (entry->leafkey)
     180             :     {                           /* tsvector */
     181        9144 :         TSVector    val = DatumGetTSVector(entry->key);
     182        9144 :         SignTSVector *res = gtsvector_alloc(ARRKEY, val->size, NULL);
     183             :         int32       len;
     184             :         int32      *arr;
     185        9144 :         WordEntry  *ptr = ARRPTR(val);
     186        9144 :         char       *words = STRPTR(val);
     187             : 
     188        9144 :         arr = GETARR(res);
     189        9144 :         len = val->size;
     190      527544 :         while (len--)
     191             :         {
     192             :             pg_crc32    c;
     193             : 
     194      518400 :             INIT_LEGACY_CRC32(c);
     195     1555200 :             COMP_LEGACY_CRC32(c, words + ptr->pos, ptr->len);
     196      518400 :             FIN_LEGACY_CRC32(c);
     197             : 
     198      518400 :             *arr = *(int32 *) &c;
     199      518400 :             arr++;
     200      518400 :             ptr++;
     201             :         }
     202             : 
     203        9144 :         qsort(GETARR(res), val->size, sizeof(int), compareint);
     204        9144 :         len = qunique(GETARR(res), val->size, sizeof(int), compareint);
     205        9144 :         if (len != val->size)
     206             :         {
     207             :             /*
     208             :              * there is a collision of hash-function; len is always less than
     209             :              * val->size
     210             :              */
     211           0 :             len = CALCGTSIZE(ARRKEY, len);
     212           0 :             res = (SignTSVector *) repalloc(res, len);
     213           0 :             SET_VARSIZE(res, len);
     214             :         }
     215             : 
     216             :         /* make signature, if array is too long */
     217        9144 :         if (VARSIZE(res) > TOAST_INDEX_TARGET)
     218             :         {
     219           0 :             SignTSVector *ressign = gtsvector_alloc(SIGNKEY, siglen, NULL);
     220             : 
     221           0 :             makesign(GETSIGN(ressign), res, siglen);
     222           0 :             res = ressign;
     223             :         }
     224             : 
     225        9144 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     226        9144 :         gistentryinit(*retval, PointerGetDatum(res),
     227             :                       entry->rel, entry->page,
     228             :                       entry->offset, false);
     229             :     }
     230        6570 :     else if (ISSIGNKEY(DatumGetPointer(entry->key)) &&
     231        6570 :              !ISALLTRUE(DatumGetPointer(entry->key)))
     232             :     {
     233             :         int32       i;
     234             :         SignTSVector *res;
     235        6570 :         BITVECP     sign = GETSIGN(DatumGetPointer(entry->key));
     236             : 
     237        6946 :         LOOPBYTE(siglen)
     238             :         {
     239        6570 :             if ((sign[i] & 0xff) != 0xff)
     240        6194 :                 PG_RETURN_POINTER(retval);
     241             :         }
     242             : 
     243         376 :         res = gtsvector_alloc(SIGNKEY | ALLISTRUE, siglen, sign);
     244         376 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     245         376 :         gistentryinit(*retval, PointerGetDatum(res),
     246             :                       entry->rel, entry->page,
     247             :                       entry->offset, false);
     248             :     }
     249        9520 :     PG_RETURN_POINTER(retval);
     250             : }
     251             : 
     252             : Datum
     253      405950 : gtsvector_decompress(PG_FUNCTION_ARGS)
     254             : {
     255             :     /*
     256             :      * We need to detoast the stored value, because the other gtsvector
     257             :      * support functions don't cope with toasted values.
     258             :      */
     259      405950 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     260      405950 :     SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(entry->key);
     261             : 
     262      405950 :     if (key != (SignTSVector *) DatumGetPointer(entry->key))
     263             :     {
     264           0 :         GISTENTRY  *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     265             : 
     266           0 :         gistentryinit(*retval, PointerGetDatum(key),
     267             :                       entry->rel, entry->page,
     268             :                       entry->offset, false);
     269             : 
     270           0 :         PG_RETURN_POINTER(retval);
     271             :     }
     272             : 
     273      405950 :     PG_RETURN_POINTER(entry);
     274             : }
     275             : 
     276             : typedef struct
     277             : {
     278             :     int32      *arrb;
     279             :     int32      *arre;
     280             : } CHKVAL;
     281             : 
     282             : /*
     283             :  * TS_execute callback for matching a tsquery operand to GIST leaf-page data
     284             :  */
     285             : static TSTernaryValue
     286      418382 : checkcondition_arr(void *checkval, QueryOperand *val, ExecPhraseData *data)
     287             : {
     288      418382 :     int32      *StopLow = ((CHKVAL *) checkval)->arrb;
     289      418382 :     int32      *StopHigh = ((CHKVAL *) checkval)->arre;
     290             :     int32      *StopMiddle;
     291             : 
     292             :     /* Loop invariant: StopLow <= val < StopHigh */
     293             : 
     294             :     /*
     295             :      * we are not able to find a prefix by hash value
     296             :      */
     297      418382 :     if (val->prefix)
     298       24384 :         return TS_MAYBE;
     299             : 
     300     2533336 :     while (StopLow < StopHigh)
     301             :     {
     302     2187860 :         StopMiddle = StopLow + (StopHigh - StopLow) / 2;
     303     2187860 :         if (*StopMiddle == val->valcrc)
     304       48522 :             return TS_MAYBE;
     305     2139338 :         else if (*StopMiddle < val->valcrc)
     306      910100 :             StopLow = StopMiddle + 1;
     307             :         else
     308     1229238 :             StopHigh = StopMiddle;
     309             :     }
     310             : 
     311      345476 :     return TS_NO;
     312             : }
     313             : 
     314             : /*
     315             :  * TS_execute callback for matching a tsquery operand to GIST non-leaf data
     316             :  */
     317             : static TSTernaryValue
     318       15812 : checkcondition_bit(void *checkval, QueryOperand *val, ExecPhraseData *data)
     319             : {
     320       15812 :     void       *key = (SignTSVector *) checkval;
     321             : 
     322             :     /*
     323             :      * we are not able to find a prefix in signature tree
     324             :      */
     325       15812 :     if (val->prefix)
     326         704 :         return TS_MAYBE;
     327             : 
     328       15108 :     if (GETBIT(GETSIGN(key), HASHVAL(val->valcrc, GETSIGLEN(key))))
     329       14330 :         return TS_MAYBE;
     330             :     else
     331         778 :         return TS_NO;
     332             : }
     333             : 
     334             : Datum
     335      303456 : gtsvector_consistent(PG_FUNCTION_ARGS)
     336             : {
     337      303456 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     338      303456 :     TSQuery     query = PG_GETARG_TSQUERY(1);
     339             : 
     340             :     /* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
     341             :     /* Oid      subtype = PG_GETARG_OID(3); */
     342      303456 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     343      303456 :     SignTSVector *key = (SignTSVector *) DatumGetPointer(entry->key);
     344             : 
     345             :     /* All cases served by this function are inexact */
     346      303456 :     *recheck = true;
     347             : 
     348      303456 :     if (!query->size)
     349           0 :         PG_RETURN_BOOL(false);
     350             : 
     351      303456 :     if (ISSIGNKEY(key))
     352             :     {
     353       13422 :         if (ISALLTRUE(key))
     354        4850 :             PG_RETURN_BOOL(true);
     355             : 
     356        8572 :         PG_RETURN_BOOL(TS_execute(GETQUERY(query),
     357             :                                   key,
     358             :                                   TS_EXEC_PHRASE_NO_POS,
     359             :                                   checkcondition_bit));
     360             :     }
     361             :     else
     362             :     {                           /* only leaf pages */
     363             :         CHKVAL      chkval;
     364             : 
     365      290034 :         chkval.arrb = GETARR(key);
     366      290034 :         chkval.arre = chkval.arrb + ARRNELEM(key);
     367      290034 :         PG_RETURN_BOOL(TS_execute(GETQUERY(query),
     368             :                                   (void *) &chkval,
     369             :                                   TS_EXEC_PHRASE_NO_POS,
     370             :                                   checkcondition_arr));
     371             :     }
     372             : }
     373             : 
     374             : static int32
     375       15364 : unionkey(BITVECP sbase, SignTSVector *add, int siglen)
     376             : {
     377             :     int32       i;
     378             : 
     379       15364 :     if (ISSIGNKEY(add))
     380             :     {
     381        9092 :         BITVECP     sadd = GETSIGN(add);
     382             : 
     383        9092 :         if (ISALLTRUE(add))
     384        2820 :             return 1;
     385             : 
     386             :         Assert(GETSIGLEN(add) == siglen);
     387             : 
     388     2026720 :         LOOPBYTE(siglen)
     389     2020448 :             sbase[i] |= sadd[i];
     390             :     }
     391             :     else
     392             :     {
     393        6272 :         int32      *ptr = GETARR(add);
     394             : 
     395      368892 :         for (i = 0; i < ARRNELEM(add); i++)
     396      362620 :             HASH(sbase, ptr[i], siglen);
     397             :     }
     398       12544 :     return 0;
     399             : }
     400             : 
     401             : 
     402             : Datum
     403        9092 : gtsvector_union(PG_FUNCTION_ARGS)
     404             : {
     405        9092 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     406        9092 :     int        *size = (int *) PG_GETARG_POINTER(1);
     407        9092 :     int         siglen = GET_SIGLEN();
     408        9092 :     SignTSVector *result = gtsvector_alloc(SIGNKEY, siglen, NULL);
     409        9092 :     BITVECP     base = GETSIGN(result);
     410             :     int32       i;
     411             : 
     412        9092 :     memset(base, 0, siglen);
     413             : 
     414       21636 :     for (i = 0; i < entryvec->n; i++)
     415             :     {
     416       15364 :         if (unionkey(base, GETENTRY(entryvec, i), siglen))
     417             :         {
     418        2820 :             result->flag |= ALLISTRUE;
     419        2820 :             SET_VARSIZE(result, CALCGTSIZE(result->flag, siglen));
     420        2820 :             break;
     421             :         }
     422             :     }
     423             : 
     424        9092 :     *size = VARSIZE(result);
     425             : 
     426        9092 :     PG_RETURN_POINTER(result);
     427             : }
     428             : 
     429             : Datum
     430        9092 : gtsvector_same(PG_FUNCTION_ARGS)
     431             : {
     432        9092 :     SignTSVector *a = (SignTSVector *) PG_GETARG_POINTER(0);
     433        9092 :     SignTSVector *b = (SignTSVector *) PG_GETARG_POINTER(1);
     434        9092 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     435        9092 :     int         siglen = GET_SIGLEN();
     436             : 
     437        9092 :     if (ISSIGNKEY(a))
     438             :     {                           /* then b also ISSIGNKEY */
     439        9092 :         if (ISALLTRUE(a) && ISALLTRUE(b))
     440        2820 :             *result = true;
     441        6272 :         else if (ISALLTRUE(a))
     442           0 :             *result = false;
     443        6272 :         else if (ISALLTRUE(b))
     444           0 :             *result = false;
     445             :         else
     446             :         {
     447             :             int32       i;
     448        6272 :             BITVECP     sa = GETSIGN(a),
     449        6272 :                         sb = GETSIGN(b);
     450             : 
     451             :             Assert(GETSIGLEN(a) == siglen && GETSIGLEN(b) == siglen);
     452             : 
     453        6272 :             *result = true;
     454      483070 :             LOOPBYTE(siglen)
     455             :             {
     456      482552 :                 if (sa[i] != sb[i])
     457             :                 {
     458        5754 :                     *result = false;
     459        5754 :                     break;
     460             :                 }
     461             :             }
     462             :         }
     463             :     }
     464             :     else
     465             :     {                           /* a and b ISARRKEY */
     466           0 :         int32       lena = ARRNELEM(a),
     467           0 :                     lenb = ARRNELEM(b);
     468             : 
     469           0 :         if (lena != lenb)
     470           0 :             *result = false;
     471             :         else
     472             :         {
     473           0 :             int32      *ptra = GETARR(a),
     474           0 :                        *ptrb = GETARR(b);
     475             :             int32       i;
     476             : 
     477           0 :             *result = true;
     478           0 :             for (i = 0; i < lena; i++)
     479           0 :                 if (ptra[i] != ptrb[i])
     480             :                 {
     481           0 :                     *result = false;
     482           0 :                     break;
     483             :                 }
     484             :         }
     485             :     }
     486             : 
     487        9092 :     PG_RETURN_POINTER(result);
     488             : }
     489             : 
     490             : static int32
     491       10678 : sizebitvec(BITVECP sign, int siglen)
     492             : {
     493       10678 :     return pg_popcount(sign, siglen);
     494             : }
     495             : 
     496             : static int
     497      284396 : hemdistsign(BITVECP a, BITVECP b, int siglen)
     498             : {
     499             :     int         i,
     500             :                 diff,
     501      284396 :                 dist = 0;
     502             : 
     503    52345690 :     LOOPBYTE(siglen)
     504             :     {
     505    52061294 :         diff = (unsigned char) (a[i] ^ b[i]);
     506             :         /* Using the popcount functions here isn't likely to win */
     507    52061294 :         dist += pg_number_of_ones[diff];
     508             :     }
     509      284396 :     return dist;
     510             : }
     511             : 
     512             : static int
     513           0 : hemdist(SignTSVector *a, SignTSVector *b)
     514             : {
     515           0 :     int         siglena = GETSIGLEN(a);
     516           0 :     int         siglenb = GETSIGLEN(b);
     517             : 
     518           0 :     if (ISALLTRUE(a))
     519             :     {
     520           0 :         if (ISALLTRUE(b))
     521           0 :             return 0;
     522             :         else
     523           0 :             return SIGLENBIT(siglenb) - sizebitvec(GETSIGN(b), siglenb);
     524             :     }
     525           0 :     else if (ISALLTRUE(b))
     526           0 :         return SIGLENBIT(siglena) - sizebitvec(GETSIGN(a), siglena);
     527             : 
     528             :     Assert(siglena == siglenb);
     529             : 
     530           0 :     return hemdistsign(GETSIGN(a), GETSIGN(b), siglena);
     531             : }
     532             : 
     533             : Datum
     534       62468 : gtsvector_penalty(PG_FUNCTION_ARGS)
     535             : {
     536       62468 :     GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
     537       62468 :     GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
     538       62468 :     float      *penalty = (float *) PG_GETARG_POINTER(2);
     539       62468 :     int         siglen = GET_SIGLEN();
     540       62468 :     SignTSVector *origval = (SignTSVector *) DatumGetPointer(origentry->key);
     541       62468 :     SignTSVector *newval = (SignTSVector *) DatumGetPointer(newentry->key);
     542       62468 :     BITVECP     orig = GETSIGN(origval);
     543             : 
     544       62468 :     *penalty = 0.0;
     545             : 
     546       62468 :     if (ISARRKEY(newval))
     547             :     {
     548       62468 :         BITVECP     sign = palloc(siglen);
     549             : 
     550       62468 :         makesign(sign, newval, siglen);
     551             : 
     552       62468 :         if (ISALLTRUE(origval))
     553             :         {
     554       10678 :             int         siglenbit = SIGLENBIT(siglen);
     555             : 
     556       10678 :             *penalty =
     557       10678 :                 (float) (siglenbit - sizebitvec(sign, siglen)) /
     558       10678 :                 (float) (siglenbit + 1);
     559             :         }
     560             :         else
     561       51790 :             *penalty = hemdistsign(sign, orig, siglen);
     562             : 
     563       62468 :         pfree(sign);
     564             :     }
     565             :     else
     566           0 :         *penalty = hemdist(origval, newval);
     567       62468 :     PG_RETURN_POINTER(penalty);
     568             : }
     569             : 
     570             : typedef struct
     571             : {
     572             :     bool        allistrue;
     573             :     BITVECP     sign;
     574             : } CACHESIGN;
     575             : 
     576             : static void
     577       12750 : fillcache(CACHESIGN *item, SignTSVector *key, int siglen)
     578             : {
     579       12750 :     item->allistrue = false;
     580       12750 :     if (ISARRKEY(key))
     581       12660 :         makesign(item->sign, key, siglen);
     582          90 :     else if (ISALLTRUE(key))
     583           0 :         item->allistrue = true;
     584             :     else
     585          90 :         memcpy(item->sign, GETSIGN(key), siglen);
     586       12750 : }
     587             : 
     588             : #define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
     589             : typedef struct
     590             : {
     591             :     OffsetNumber pos;
     592             :     int32       cost;
     593             : } SPLITCOST;
     594             : 
     595             : static int
     596       31320 : comparecost(const void *va, const void *vb)
     597             : {
     598       31320 :     const SPLITCOST *a = (const SPLITCOST *) va;
     599       31320 :     const SPLITCOST *b = (const SPLITCOST *) vb;
     600             : 
     601       31320 :     if (a->cost == b->cost)
     602       13320 :         return 0;
     603             :     else
     604       18000 :         return (a->cost > b->cost) ? 1 : -1;
     605             : }
     606             : 
     607             : 
     608             : static int
     609      208738 : hemdistcache(CACHESIGN *a, CACHESIGN *b, int siglen)
     610             : {
     611      208738 :     if (a->allistrue)
     612             :     {
     613           0 :         if (b->allistrue)
     614           0 :             return 0;
     615             :         else
     616           0 :             return SIGLENBIT(siglen) - sizebitvec(b->sign, siglen);
     617             :     }
     618      208738 :     else if (b->allistrue)
     619           0 :         return SIGLENBIT(siglen) - sizebitvec(a->sign, siglen);
     620             : 
     621      208738 :     return hemdistsign(a->sign, b->sign, siglen);
     622             : }
     623             : 
     624             : Datum
     625         408 : gtsvector_picksplit(PG_FUNCTION_ARGS)
     626             : {
     627         408 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     628         408 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     629         408 :     int         siglen = GET_SIGLEN();
     630             :     OffsetNumber k,
     631             :                 j;
     632             :     SignTSVector *datum_l,
     633             :                *datum_r;
     634             :     BITVECP     union_l,
     635             :                 union_r;
     636             :     int32       size_alpha,
     637             :                 size_beta;
     638             :     int32       size_waste,
     639         408 :                 waste = -1;
     640             :     int32       nbytes;
     641         408 :     OffsetNumber seed_1 = 0,
     642         408 :                 seed_2 = 0;
     643             :     OffsetNumber *left,
     644             :                *right;
     645             :     OffsetNumber maxoff;
     646             :     BITVECP     ptr;
     647             :     int         i;
     648             :     CACHESIGN  *cache;
     649             :     char       *cache_sign;
     650             :     SPLITCOST  *costvector;
     651             : 
     652         408 :     maxoff = entryvec->n - 2;
     653         408 :     nbytes = (maxoff + 2) * sizeof(OffsetNumber);
     654         408 :     v->spl_left = (OffsetNumber *) palloc(nbytes);
     655         408 :     v->spl_right = (OffsetNumber *) palloc(nbytes);
     656             : 
     657         408 :     cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2));
     658         408 :     cache_sign = palloc(siglen * (maxoff + 2));
     659             : 
     660       13566 :     for (j = 0; j < maxoff + 2; j++)
     661       13158 :         cache[j].sign = &cache_sign[siglen * j];
     662             : 
     663         408 :     fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber),
     664             :               siglen);
     665             : 
     666       12342 :     for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
     667             :     {
     668      195172 :         for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
     669             :         {
     670      183238 :             if (k == FirstOffsetNumber)
     671       11934 :                 fillcache(&cache[j], GETENTRY(entryvec, j), siglen);
     672             : 
     673      183238 :             size_waste = hemdistcache(&(cache[j]), &(cache[k]), siglen);
     674      183238 :             if (size_waste > waste)
     675             :             {
     676        2582 :                 waste = size_waste;
     677        2582 :                 seed_1 = k;
     678        2582 :                 seed_2 = j;
     679             :             }
     680             :         }
     681             :     }
     682             : 
     683         408 :     left = v->spl_left;
     684         408 :     v->spl_nleft = 0;
     685         408 :     right = v->spl_right;
     686         408 :     v->spl_nright = 0;
     687             : 
     688         408 :     if (seed_1 == 0 || seed_2 == 0)
     689             :     {
     690           0 :         seed_1 = 1;
     691           0 :         seed_2 = 2;
     692             :     }
     693             : 
     694             :     /* form initial .. */
     695         408 :     datum_l = gtsvector_alloc(SIGNKEY | (cache[seed_1].allistrue ? ALLISTRUE : 0),
     696         408 :                               siglen, cache[seed_1].sign);
     697         408 :     datum_r = gtsvector_alloc(SIGNKEY | (cache[seed_2].allistrue ? ALLISTRUE : 0),
     698         408 :                               siglen, cache[seed_2].sign);
     699         408 :     union_l = GETSIGN(datum_l);
     700         408 :     union_r = GETSIGN(datum_r);
     701         408 :     maxoff = OffsetNumberNext(maxoff);
     702         408 :     fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff), siglen);
     703             :     /* sort before ... */
     704         408 :     costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
     705       13158 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     706             :     {
     707       12750 :         costvector[j - 1].pos = j;
     708       12750 :         size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]), siglen);
     709       12750 :         size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
     710       12750 :         costvector[j - 1].cost = abs(size_alpha - size_beta);
     711             :     }
     712         408 :     qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);
     713             : 
     714       13158 :     for (k = 0; k < maxoff; k++)
     715             :     {
     716       12750 :         j = costvector[k].pos;
     717       12750 :         if (j == seed_1)
     718             :         {
     719         408 :             *left++ = j;
     720         408 :             v->spl_nleft++;
     721         408 :             continue;
     722             :         }
     723       12342 :         else if (j == seed_2)
     724             :         {
     725         408 :             *right++ = j;
     726         408 :             v->spl_nright++;
     727         408 :             continue;
     728             :         }
     729             : 
     730       11934 :         if (ISALLTRUE(datum_l) || cache[j].allistrue)
     731             :         {
     732           0 :             if (ISALLTRUE(datum_l) && cache[j].allistrue)
     733           0 :                 size_alpha = 0;
     734             :             else
     735           0 :                 size_alpha = SIGLENBIT(siglen) -
     736           0 :                     sizebitvec((cache[j].allistrue) ?
     737             :                                GETSIGN(datum_l) :
     738           0 :                                cache[j].sign,
     739             :                                siglen);
     740             :         }
     741             :         else
     742       11934 :             size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l), siglen);
     743             : 
     744       11934 :         if (ISALLTRUE(datum_r) || cache[j].allistrue)
     745             :         {
     746           0 :             if (ISALLTRUE(datum_r) && cache[j].allistrue)
     747           0 :                 size_beta = 0;
     748             :             else
     749           0 :                 size_beta = SIGLENBIT(siglen) -
     750           0 :                     sizebitvec((cache[j].allistrue) ?
     751             :                                GETSIGN(datum_r) :
     752           0 :                                cache[j].sign,
     753             :                                siglen);
     754             :         }
     755             :         else
     756       11934 :             size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r), siglen);
     757             : 
     758       11934 :         if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1))
     759             :         {
     760        5860 :             if (ISALLTRUE(datum_l) || cache[j].allistrue)
     761             :             {
     762           0 :                 if (!ISALLTRUE(datum_l))
     763           0 :                     memset(GETSIGN(datum_l), 0xff, siglen);
     764             :             }
     765             :             else
     766             :             {
     767        5860 :                 ptr = cache[j].sign;
     768      957398 :                 LOOPBYTE(siglen)
     769      951538 :                     union_l[i] |= ptr[i];
     770             :             }
     771        5860 :             *left++ = j;
     772        5860 :             v->spl_nleft++;
     773             :         }
     774             :         else
     775             :         {
     776        6074 :             if (ISALLTRUE(datum_r) || cache[j].allistrue)
     777             :             {
     778           0 :                 if (!ISALLTRUE(datum_r))
     779           0 :                     memset(GETSIGN(datum_r), 0xff, siglen);
     780             :             }
     781             :             else
     782             :             {
     783        6074 :                 ptr = cache[j].sign;
     784      984826 :                 LOOPBYTE(siglen)
     785      978752 :                     union_r[i] |= ptr[i];
     786             :             }
     787        6074 :             *right++ = j;
     788        6074 :             v->spl_nright++;
     789             :         }
     790             :     }
     791             : 
     792         408 :     *right = *left = FirstOffsetNumber;
     793         408 :     v->spl_ldatum = PointerGetDatum(datum_l);
     794         408 :     v->spl_rdatum = PointerGetDatum(datum_r);
     795             : 
     796         408 :     PG_RETURN_POINTER(v);
     797             : }
     798             : 
     799             : /*
     800             :  * Formerly, gtsvector_consistent was declared in pg_proc.h with arguments
     801             :  * that did not match the documented conventions for GiST support functions.
     802             :  * We fixed that, but we still need a pg_proc entry with the old signature
     803             :  * to support reloading pre-9.6 contrib/tsearch2 opclass declarations.
     804             :  * This compatibility function should go away eventually.
     805             :  */
     806             : Datum
     807           0 : gtsvector_consistent_oldsig(PG_FUNCTION_ARGS)
     808             : {
     809           0 :     return gtsvector_consistent(fcinfo);
     810             : }
     811             : 
     812             : Datum
     813         362 : gtsvector_options(PG_FUNCTION_ARGS)
     814             : {
     815         362 :     local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
     816             : 
     817         362 :     init_local_reloptions(relopts, sizeof(GistTsVectorOptions));
     818         362 :     add_local_int_reloption(relopts, "siglen", "signature length",
     819             :                             SIGLEN_DEFAULT, 1, SIGLEN_MAX,
     820             :                             offsetof(GistTsVectorOptions, siglen));
     821             : 
     822         362 :     PG_RETURN_VOID();
     823             : }

Generated by: LCOV version 1.14