LCOV - code coverage report
Current view: top level - src/backend/utils/adt - tsgistidx.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 260 332 78.3 %
Date: 2020-06-03 11:07:14 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-2020, 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           0 :     ereport(ERROR,
      91             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      92             :              errmsg("gtsvector_in not implemented")));
      93             :     PG_RETURN_DATUM(0);
      94             : }
      95             : 
      96             : #define SINGOUTSTR  "%d true bits, %d false bits"
      97             : #define ARROUTSTR   "%d unique words"
      98             : #define EXTRALEN    ( 2*13 )
      99             : 
     100             : static int  outbuf_maxlen = 0;
     101             : 
     102             : Datum
     103           0 : gtsvectorout(PG_FUNCTION_ARGS)
     104             : {
     105           0 :     SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(PG_GETARG_POINTER(0));
     106             :     char       *outbuf;
     107             : 
     108           0 :     if (outbuf_maxlen == 0)
     109           0 :         outbuf_maxlen = 2 * EXTRALEN + Max(strlen(SINGOUTSTR), strlen(ARROUTSTR)) + 1;
     110           0 :     outbuf = palloc(outbuf_maxlen);
     111             : 
     112           0 :     if (ISARRKEY(key))
     113           0 :         sprintf(outbuf, ARROUTSTR, (int) ARRNELEM(key));
     114             :     else
     115             :     {
     116           0 :         int         siglen = GETSIGLEN(key);
     117           0 :         int         cnttrue = (ISALLTRUE(key)) ? SIGLENBIT(siglen) : sizebitvec(GETSIGN(key), siglen);
     118             : 
     119           0 :         sprintf(outbuf, SINGOUTSTR, cnttrue, (int) SIGLENBIT(siglen) - cnttrue);
     120             :     }
     121             : 
     122           0 :     PG_FREE_IF_COPY(key, 0);
     123           0 :     PG_RETURN_POINTER(outbuf);
     124             : }
     125             : 
     126             : static int
     127     2417424 : compareint(const void *va, const void *vb)
     128             : {
     129     2417424 :     int32       a = *((const int32 *) va);
     130     2417424 :     int32       b = *((const int32 *) vb);
     131             : 
     132     2417424 :     if (a == b)
     133           0 :         return 0;
     134     2417424 :     return (a > b) ? 1 : -1;
     135             : }
     136             : 
     137             : static void
     138       50134 : makesign(BITVECP sign, SignTSVector *a, int siglen)
     139             : {
     140             :     int32       k,
     141       50134 :                 len = ARRNELEM(a);
     142       50134 :     int32      *ptr = GETARR(a);
     143             : 
     144       50134 :     MemSet((void *) sign, 0, siglen);
     145     2804772 :     for (k = 0; k < len; k++)
     146     2754638 :         HASH(sign, ptr[k], siglen);
     147       50134 : }
     148             : 
     149             : static SignTSVector *
     150       12974 : gtsvector_alloc(int flag, int len, BITVECP sign)
     151             : {
     152       12974 :     int         size = CALCGTSIZE(flag, len);
     153       12974 :     SignTSVector *res = palloc(size);
     154             : 
     155       12974 :     SET_VARSIZE(res, size);
     156       12974 :     res->flag = flag;
     157             : 
     158       12974 :     if ((flag & (SIGNKEY | ALLISTRUE)) == SIGNKEY && sign)
     159         548 :         memcpy(GETSIGN(res), sign, len);
     160             : 
     161       12974 :     return res;
     162             : }
     163             : 
     164             : 
     165             : Datum
     166       10442 : gtsvector_compress(PG_FUNCTION_ARGS)
     167             : {
     168       10442 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     169       10442 :     int         siglen = GET_SIGLEN();
     170       10442 :     GISTENTRY  *retval = entry;
     171             : 
     172       10442 :     if (entry->leafkey)
     173             :     {                           /* tsvector */
     174        6096 :         TSVector    val = DatumGetTSVector(entry->key);
     175        6096 :         SignTSVector *res = gtsvector_alloc(ARRKEY, val->size, NULL);
     176             :         int32       len;
     177             :         int32      *arr;
     178        6096 :         WordEntry  *ptr = ARRPTR(val);
     179        6096 :         char       *words = STRPTR(val);
     180             : 
     181        6096 :         arr = GETARR(res);
     182        6096 :         len = val->size;
     183      351696 :         while (len--)
     184             :         {
     185             :             pg_crc32    c;
     186             : 
     187      345600 :             INIT_LEGACY_CRC32(c);
     188     1036800 :             COMP_LEGACY_CRC32(c, words + ptr->pos, ptr->len);
     189      345600 :             FIN_LEGACY_CRC32(c);
     190             : 
     191      345600 :             *arr = *(int32 *) &c;
     192      345600 :             arr++;
     193      345600 :             ptr++;
     194             :         }
     195             : 
     196        6096 :         qsort(GETARR(res), val->size, sizeof(int), compareint);
     197        6096 :         len = qunique(GETARR(res), val->size, sizeof(int), compareint);
     198        6096 :         if (len != val->size)
     199             :         {
     200             :             /*
     201             :              * there is a collision of hash-function; len is always less than
     202             :              * val->size
     203             :              */
     204           0 :             len = CALCGTSIZE(ARRKEY, len);
     205           0 :             res = (SignTSVector *) repalloc((void *) res, len);
     206           0 :             SET_VARSIZE(res, len);
     207             :         }
     208             : 
     209             :         /* make signature, if array is too long */
     210        6096 :         if (VARSIZE(res) > TOAST_INDEX_TARGET)
     211             :         {
     212           0 :             SignTSVector *ressign = gtsvector_alloc(SIGNKEY, siglen, NULL);
     213             : 
     214           0 :             makesign(GETSIGN(ressign), res, siglen);
     215           0 :             res = ressign;
     216             :         }
     217             : 
     218        6096 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     219        6096 :         gistentryinit(*retval, PointerGetDatum(res),
     220             :                       entry->rel, entry->page,
     221             :                       entry->offset, false);
     222             :     }
     223        4346 :     else if (ISSIGNKEY(DatumGetPointer(entry->key)) &&
     224        4346 :              !ISALLTRUE(DatumGetPointer(entry->key)))
     225             :     {
     226             :         int32       i;
     227             :         SignTSVector *res;
     228        4346 :         BITVECP     sign = GETSIGN(DatumGetPointer(entry->key));
     229             : 
     230        4602 :         LOOPBYTE(siglen)
     231             :         {
     232        4346 :             if ((sign[i] & 0xff) != 0xff)
     233        4090 :                 PG_RETURN_POINTER(retval);
     234             :         }
     235             : 
     236         256 :         res = gtsvector_alloc(SIGNKEY | ALLISTRUE, siglen, sign);
     237         256 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     238         256 :         gistentryinit(*retval, PointerGetDatum(res),
     239             :                       entry->rel, entry->page,
     240             :                       entry->offset, false);
     241             :     }
     242        6352 :     PG_RETURN_POINTER(retval);
     243             : }
     244             : 
     245             : Datum
     246      237656 : gtsvector_decompress(PG_FUNCTION_ARGS)
     247             : {
     248             :     /*
     249             :      * We need to detoast the stored value, because the other gtsvector
     250             :      * support functions don't cope with toasted values.
     251             :      */
     252      237656 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     253      237656 :     SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(entry->key);
     254             : 
     255      237656 :     if (key != (SignTSVector *) DatumGetPointer(entry->key))
     256             :     {
     257           0 :         GISTENTRY  *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     258             : 
     259           0 :         gistentryinit(*retval, PointerGetDatum(key),
     260             :                       entry->rel, entry->page,
     261             :                       entry->offset, false);
     262             : 
     263           0 :         PG_RETURN_POINTER(retval);
     264             :     }
     265             : 
     266      237656 :     PG_RETURN_POINTER(entry);
     267             : }
     268             : 
     269             : typedef struct
     270             : {
     271             :     int32      *arrb;
     272             :     int32      *arre;
     273             : } CHKVAL;
     274             : 
     275             : /*
     276             :  * is there value 'val' in array or not ?
     277             :  */
     278             : static bool
     279      235538 : checkcondition_arr(void *checkval, QueryOperand *val, ExecPhraseData *data)
     280             : {
     281      235538 :     int32      *StopLow = ((CHKVAL *) checkval)->arrb;
     282      235538 :     int32      *StopHigh = ((CHKVAL *) checkval)->arre;
     283             :     int32      *StopMiddle;
     284             : 
     285             :     /* Loop invariant: StopLow <= val < StopHigh */
     286             : 
     287             :     /*
     288             :      * we are not able to find a prefix by hash value
     289             :      */
     290      235538 :     if (val->prefix)
     291        8128 :         return true;
     292             : 
     293     1464330 :     while (StopLow < StopHigh)
     294             :     {
     295     1265010 :         StopMiddle = StopLow + (StopHigh - StopLow) / 2;
     296     1265010 :         if (*StopMiddle == val->valcrc)
     297       28090 :             return true;
     298     1236920 :         else if (*StopMiddle < val->valcrc)
     299      506160 :             StopLow = StopMiddle + 1;
     300             :         else
     301      730760 :             StopHigh = StopMiddle;
     302             :     }
     303             : 
     304      199320 :     return false;
     305             : }
     306             : 
     307             : static bool
     308        5198 : checkcondition_bit(void *checkval, QueryOperand *val, ExecPhraseData *data)
     309             : {
     310        5198 :     void       *key = (SignTSVector *) checkval;
     311             : 
     312             :     /*
     313             :      * we are not able to find a prefix in signature tree
     314             :      */
     315        5198 :     if (val->prefix)
     316         234 :         return true;
     317        4964 :     return GETBIT(GETSIGN(key), HASHVAL(val->valcrc, GETSIGLEN(key)));
     318             : }
     319             : 
     320             : Datum
     321      169240 : gtsvector_consistent(PG_FUNCTION_ARGS)
     322             : {
     323      169240 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     324      169240 :     TSQuery     query = PG_GETARG_TSQUERY(1);
     325             : 
     326             :     /* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
     327             :     /* Oid      subtype = PG_GETARG_OID(3); */
     328      169240 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     329      169240 :     SignTSVector *key = (SignTSVector *) DatumGetPointer(entry->key);
     330             : 
     331             :     /* All cases served by this function are inexact */
     332      169240 :     *recheck = true;
     333             : 
     334      169240 :     if (!query->size)
     335           0 :         PG_RETURN_BOOL(false);
     336             : 
     337      169240 :     if (ISSIGNKEY(key))
     338             :     {
     339        7534 :         if (ISALLTRUE(key))
     340        2772 :             PG_RETURN_BOOL(true);
     341             : 
     342             :         /* since signature is lossy, cannot specify CALC_NOT here */
     343        4762 :         PG_RETURN_BOOL(TS_execute(GETQUERY(query),
     344             :                                   key,
     345             :                                   TS_EXEC_PHRASE_NO_POS,
     346             :                                   checkcondition_bit));
     347             :     }
     348             :     else
     349             :     {                           /* only leaf pages */
     350             :         CHKVAL      chkval;
     351             : 
     352      161706 :         chkval.arrb = GETARR(key);
     353      161706 :         chkval.arre = chkval.arrb + ARRNELEM(key);
     354      161706 :         PG_RETURN_BOOL(TS_execute(GETQUERY(query),
     355             :                                   (void *) &chkval,
     356             :                                   TS_EXEC_PHRASE_NO_POS | TS_EXEC_CALC_NOT,
     357             :                                   checkcondition_arr));
     358             :     }
     359             : }
     360             : 
     361             : static int32
     362       10268 : unionkey(BITVECP sbase, SignTSVector *add, int siglen)
     363             : {
     364             :     int32       i;
     365             : 
     366       10268 :     if (ISSIGNKEY(add))
     367             :     {
     368        6074 :         BITVECP     sadd = GETSIGN(add);
     369             : 
     370        6074 :         if (ISALLTRUE(add))
     371        1880 :             return 1;
     372             : 
     373             :         Assert(GETSIGLEN(add) == siglen);
     374             : 
     375     1357290 :         LOOPBYTE(siglen)
     376     1353096 :             sbase[i] |= sadd[i];
     377             :     }
     378             :     else
     379             :     {
     380        4194 :         int32      *ptr = GETARR(add);
     381             : 
     382      246614 :         for (i = 0; i < ARRNELEM(add); i++)
     383      242420 :             HASH(sbase, ptr[i], siglen);
     384             :     }
     385        8388 :     return 0;
     386             : }
     387             : 
     388             : 
     389             : Datum
     390        6074 : gtsvector_union(PG_FUNCTION_ARGS)
     391             : {
     392        6074 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     393        6074 :     int        *size = (int *) PG_GETARG_POINTER(1);
     394        6074 :     int         siglen = GET_SIGLEN();
     395        6074 :     SignTSVector *result = gtsvector_alloc(SIGNKEY, siglen, NULL);
     396        6074 :     BITVECP     base = GETSIGN(result);
     397             :     int32       i;
     398             : 
     399        6074 :     memset(base, 0, siglen);
     400             : 
     401       14462 :     for (i = 0; i < entryvec->n; i++)
     402             :     {
     403       10268 :         if (unionkey(base, GETENTRY(entryvec, i), siglen))
     404             :         {
     405        1880 :             result->flag |= ALLISTRUE;
     406        1880 :             SET_VARSIZE(result, CALCGTSIZE(result->flag, siglen));
     407        1880 :             break;
     408             :         }
     409             :     }
     410             : 
     411        6074 :     *size = VARSIZE(result);
     412             : 
     413        6074 :     PG_RETURN_POINTER(result);
     414             : }
     415             : 
     416             : Datum
     417        6074 : gtsvector_same(PG_FUNCTION_ARGS)
     418             : {
     419        6074 :     SignTSVector *a = (SignTSVector *) PG_GETARG_POINTER(0);
     420        6074 :     SignTSVector *b = (SignTSVector *) PG_GETARG_POINTER(1);
     421        6074 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     422        6074 :     int         siglen = GET_SIGLEN();
     423             : 
     424        6074 :     if (ISSIGNKEY(a))
     425             :     {                           /* then b also ISSIGNKEY */
     426        6074 :         if (ISALLTRUE(a) && ISALLTRUE(b))
     427        1880 :             *result = true;
     428        4194 :         else if (ISALLTRUE(a))
     429           0 :             *result = false;
     430        4194 :         else if (ISALLTRUE(b))
     431           0 :             *result = false;
     432             :         else
     433             :         {
     434             :             int32       i;
     435        4194 :             BITVECP     sa = GETSIGN(a),
     436        4194 :                         sb = GETSIGN(b);
     437             : 
     438             :             Assert(GETSIGLEN(a) == siglen && GETSIGLEN(b) == siglen);
     439             : 
     440        4194 :             *result = true;
     441      339534 :             LOOPBYTE(siglen)
     442             :             {
     443      339138 :                 if (sa[i] != sb[i])
     444             :                 {
     445        3798 :                     *result = false;
     446        3798 :                     break;
     447             :                 }
     448             :             }
     449             :         }
     450             :     }
     451             :     else
     452             :     {                           /* a and b ISARRKEY */
     453           0 :         int32       lena = ARRNELEM(a),
     454           0 :                     lenb = ARRNELEM(b);
     455             : 
     456           0 :         if (lena != lenb)
     457           0 :             *result = false;
     458             :         else
     459             :         {
     460           0 :             int32      *ptra = GETARR(a),
     461           0 :                        *ptrb = GETARR(b);
     462             :             int32       i;
     463             : 
     464           0 :             *result = true;
     465           0 :             for (i = 0; i < lena; i++)
     466           0 :                 if (ptra[i] != ptrb[i])
     467             :                 {
     468           0 :                     *result = false;
     469           0 :                     break;
     470             :                 }
     471             :         }
     472             :     }
     473             : 
     474        6074 :     PG_RETURN_POINTER(result);
     475             : }
     476             : 
     477             : static int32
     478        7020 : sizebitvec(BITVECP sign, int siglen)
     479             : {
     480        7020 :     return pg_popcount(sign, siglen);
     481             : }
     482             : 
     483             : static int
     484      188194 : hemdistsign(BITVECP a, BITVECP b, int siglen)
     485             : {
     486             :     int         i,
     487             :                 diff,
     488      188194 :                 dist = 0;
     489             : 
     490    34873484 :     LOOPBYTE(siglen)
     491             :     {
     492    34685290 :         diff = (unsigned char) (a[i] ^ b[i]);
     493             :         /* Using the popcount functions here isn't likely to win */
     494    34685290 :         dist += pg_number_of_ones[diff];
     495             :     }
     496      188194 :     return dist;
     497             : }
     498             : 
     499             : static int
     500           0 : hemdist(SignTSVector *a, SignTSVector *b)
     501             : {
     502           0 :     int         siglena = GETSIGLEN(a);
     503           0 :     int         siglenb = GETSIGLEN(b);
     504             : 
     505           0 :     if (ISALLTRUE(a))
     506             :     {
     507           0 :         if (ISALLTRUE(b))
     508           0 :             return 0;
     509             :         else
     510           0 :             return SIGLENBIT(siglenb) - sizebitvec(GETSIGN(b), siglenb);
     511             :     }
     512           0 :     else if (ISALLTRUE(b))
     513           0 :         return SIGLENBIT(siglena) - sizebitvec(GETSIGN(a), siglena);
     514             : 
     515             :     Assert(siglena == siglenb);
     516             : 
     517           0 :     return hemdistsign(GETSIGN(a), GETSIGN(b), siglena);
     518             : }
     519             : 
     520             : Datum
     521       41710 : gtsvector_penalty(PG_FUNCTION_ARGS)
     522             : {
     523       41710 :     GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
     524       41710 :     GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
     525       41710 :     float      *penalty = (float *) PG_GETARG_POINTER(2);
     526       41710 :     int         siglen = GET_SIGLEN();
     527       41710 :     SignTSVector *origval = (SignTSVector *) DatumGetPointer(origentry->key);
     528       41710 :     SignTSVector *newval = (SignTSVector *) DatumGetPointer(newentry->key);
     529       41710 :     BITVECP     orig = GETSIGN(origval);
     530             : 
     531       41710 :     *penalty = 0.0;
     532             : 
     533       41710 :     if (ISARRKEY(newval))
     534             :     {
     535       41710 :         BITVECP     sign = palloc(siglen);
     536             : 
     537       41710 :         makesign(sign, newval, siglen);
     538             : 
     539       41710 :         if (ISALLTRUE(origval))
     540             :         {
     541        7020 :             int         siglenbit = SIGLENBIT(siglen);
     542             : 
     543        7020 :             *penalty =
     544        7020 :                 (float) (siglenbit - sizebitvec(sign, siglen)) /
     545        7020 :                 (float) (siglenbit + 1);
     546             :         }
     547             :         else
     548       34690 :             *penalty = hemdistsign(sign, orig, siglen);
     549             : 
     550       41710 :         pfree(sign);
     551             :     }
     552             :     else
     553           0 :         *penalty = hemdist(origval, newval);
     554       41710 :     PG_RETURN_POINTER(penalty);
     555             : }
     556             : 
     557             : typedef struct
     558             : {
     559             :     bool        allistrue;
     560             :     BITVECP     sign;
     561             : } CACHESIGN;
     562             : 
     563             : static void
     564        8484 : fillcache(CACHESIGN *item, SignTSVector *key, int siglen)
     565             : {
     566        8484 :     item->allistrue = false;
     567        8484 :     if (ISARRKEY(key))
     568        8424 :         makesign(item->sign, key, siglen);
     569          60 :     else if (ISALLTRUE(key))
     570           0 :         item->allistrue = true;
     571             :     else
     572          60 :         memcpy((void *) item->sign, (void *) GETSIGN(key), siglen);
     573        8484 : }
     574             : 
     575             : #define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
     576             : typedef struct
     577             : {
     578             :     OffsetNumber pos;
     579             :     int32       cost;
     580             : } SPLITCOST;
     581             : 
     582             : static int
     583       20782 : comparecost(const void *va, const void *vb)
     584             : {
     585       20782 :     const SPLITCOST *a = (const SPLITCOST *) va;
     586       20782 :     const SPLITCOST *b = (const SPLITCOST *) vb;
     587             : 
     588       20782 :     if (a->cost == b->cost)
     589        8866 :         return 0;
     590             :     else
     591       11916 :         return (a->cost > b->cost) ? 1 : -1;
     592             : }
     593             : 
     594             : 
     595             : static int
     596      137632 : hemdistcache(CACHESIGN *a, CACHESIGN *b, int siglen)
     597             : {
     598      137632 :     if (a->allistrue)
     599             :     {
     600           0 :         if (b->allistrue)
     601           0 :             return 0;
     602             :         else
     603           0 :             return SIGLENBIT(siglen) - sizebitvec(b->sign, siglen);
     604             :     }
     605      137632 :     else if (b->allistrue)
     606           0 :         return SIGLENBIT(siglen) - sizebitvec(a->sign, siglen);
     607             : 
     608      137632 :     return hemdistsign(a->sign, b->sign, siglen);
     609             : }
     610             : 
     611             : Datum
     612         274 : gtsvector_picksplit(PG_FUNCTION_ARGS)
     613             : {
     614         274 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     615         274 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     616         274 :     int         siglen = GET_SIGLEN();
     617             :     OffsetNumber k,
     618             :                 j;
     619             :     SignTSVector *datum_l,
     620             :                *datum_r;
     621             :     BITVECP     union_l,
     622             :                 union_r;
     623             :     int32       size_alpha,
     624             :                 size_beta;
     625             :     int32       size_waste,
     626         274 :                 waste = -1;
     627             :     int32       nbytes;
     628         274 :     OffsetNumber seed_1 = 0,
     629         274 :                 seed_2 = 0;
     630             :     OffsetNumber *left,
     631             :                *right;
     632             :     OffsetNumber maxoff;
     633             :     BITVECP     ptr;
     634             :     int         i;
     635             :     CACHESIGN  *cache;
     636             :     char       *cache_sign;
     637             :     SPLITCOST  *costvector;
     638             : 
     639         274 :     maxoff = entryvec->n - 2;
     640         274 :     nbytes = (maxoff + 2) * sizeof(OffsetNumber);
     641         274 :     v->spl_left = (OffsetNumber *) palloc(nbytes);
     642         274 :     v->spl_right = (OffsetNumber *) palloc(nbytes);
     643             : 
     644         274 :     cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2));
     645         274 :     cache_sign = palloc(siglen * (maxoff + 2));
     646             : 
     647        9032 :     for (j = 0; j < maxoff + 2; j++)
     648        8758 :         cache[j].sign = &cache_sign[siglen * j];
     649             : 
     650         274 :     fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber),
     651             :               siglen);
     652             : 
     653        8210 :     for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
     654             :     {
     655      128600 :         for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
     656             :         {
     657      120664 :             if (k == FirstOffsetNumber)
     658        7936 :                 fillcache(&cache[j], GETENTRY(entryvec, j), siglen);
     659             : 
     660      120664 :             size_waste = hemdistcache(&(cache[j]), &(cache[k]), siglen);
     661      120664 :             if (size_waste > waste)
     662             :             {
     663        1684 :                 waste = size_waste;
     664        1684 :                 seed_1 = k;
     665        1684 :                 seed_2 = j;
     666             :             }
     667             :         }
     668             :     }
     669             : 
     670         274 :     left = v->spl_left;
     671         274 :     v->spl_nleft = 0;
     672         274 :     right = v->spl_right;
     673         274 :     v->spl_nright = 0;
     674             : 
     675         274 :     if (seed_1 == 0 || seed_2 == 0)
     676             :     {
     677           0 :         seed_1 = 1;
     678           0 :         seed_2 = 2;
     679             :     }
     680             : 
     681             :     /* form initial .. */
     682         274 :     datum_l = gtsvector_alloc(SIGNKEY | (cache[seed_1].allistrue ? ALLISTRUE : 0),
     683         274 :                               siglen, cache[seed_1].sign);
     684         274 :     datum_r = gtsvector_alloc(SIGNKEY | (cache[seed_2].allistrue ? ALLISTRUE : 0),
     685         274 :                               siglen, cache[seed_2].sign);
     686         274 :     union_l = GETSIGN(datum_l);
     687         274 :     union_r = GETSIGN(datum_r);
     688         274 :     maxoff = OffsetNumberNext(maxoff);
     689         274 :     fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff), siglen);
     690             :     /* sort before ... */
     691         274 :     costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
     692        8758 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     693             :     {
     694        8484 :         costvector[j - 1].pos = j;
     695        8484 :         size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]), siglen);
     696        8484 :         size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
     697        8484 :         costvector[j - 1].cost = Abs(size_alpha - size_beta);
     698             :     }
     699         274 :     qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
     700             : 
     701        8758 :     for (k = 0; k < maxoff; k++)
     702             :     {
     703        8484 :         j = costvector[k].pos;
     704        8484 :         if (j == seed_1)
     705             :         {
     706         274 :             *left++ = j;
     707         274 :             v->spl_nleft++;
     708         274 :             continue;
     709             :         }
     710        8210 :         else if (j == seed_2)
     711             :         {
     712         274 :             *right++ = j;
     713         274 :             v->spl_nright++;
     714         274 :             continue;
     715             :         }
     716             : 
     717        7936 :         if (ISALLTRUE(datum_l) || cache[j].allistrue)
     718             :         {
     719           0 :             if (ISALLTRUE(datum_l) && cache[j].allistrue)
     720           0 :                 size_alpha = 0;
     721             :             else
     722           0 :                 size_alpha = SIGLENBIT(siglen) -
     723           0 :                     sizebitvec((cache[j].allistrue) ?
     724             :                                GETSIGN(datum_l) :
     725           0 :                                GETSIGN(cache[j].sign),
     726             :                                siglen);
     727             :         }
     728             :         else
     729        7936 :             size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l), siglen);
     730             : 
     731        7936 :         if (ISALLTRUE(datum_r) || cache[j].allistrue)
     732             :         {
     733           0 :             if (ISALLTRUE(datum_r) && cache[j].allistrue)
     734           0 :                 size_beta = 0;
     735             :             else
     736           0 :                 size_beta = SIGLENBIT(siglen) -
     737           0 :                     sizebitvec((cache[j].allistrue) ?
     738             :                                GETSIGN(datum_r) :
     739           0 :                                GETSIGN(cache[j].sign),
     740             :                                siglen);
     741             :         }
     742             :         else
     743        7936 :             size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r), siglen);
     744             : 
     745        7936 :         if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1))
     746             :         {
     747        3880 :             if (ISALLTRUE(datum_l) || cache[j].allistrue)
     748             :             {
     749           0 :                 if (!ISALLTRUE(datum_l))
     750           0 :                     MemSet((void *) GETSIGN(datum_l), 0xff, siglen);
     751             :             }
     752             :             else
     753             :             {
     754        3880 :                 ptr = cache[j].sign;
     755      629480 :                 LOOPBYTE(siglen)
     756      625600 :                     union_l[i] |= ptr[i];
     757             :             }
     758        3880 :             *left++ = j;
     759        3880 :             v->spl_nleft++;
     760             :         }
     761             :         else
     762             :         {
     763        4056 :             if (ISALLTRUE(datum_r) || cache[j].allistrue)
     764             :             {
     765           0 :                 if (!ISALLTRUE(datum_r))
     766           0 :                     MemSet((void *) GETSIGN(datum_r), 0xff, siglen);
     767             :             }
     768             :             else
     769             :             {
     770        4056 :                 ptr = cache[j].sign;
     771      658272 :                 LOOPBYTE(siglen)
     772      654216 :                     union_r[i] |= ptr[i];
     773             :             }
     774        4056 :             *right++ = j;
     775        4056 :             v->spl_nright++;
     776             :         }
     777             :     }
     778             : 
     779         274 :     *right = *left = FirstOffsetNumber;
     780         274 :     v->spl_ldatum = PointerGetDatum(datum_l);
     781         274 :     v->spl_rdatum = PointerGetDatum(datum_r);
     782             : 
     783         274 :     PG_RETURN_POINTER(v);
     784             : }
     785             : 
     786             : /*
     787             :  * Formerly, gtsvector_consistent was declared in pg_proc.h with arguments
     788             :  * that did not match the documented conventions for GiST support functions.
     789             :  * We fixed that, but we still need a pg_proc entry with the old signature
     790             :  * to support reloading pre-9.6 contrib/tsearch2 opclass declarations.
     791             :  * This compatibility function should go away eventually.
     792             :  */
     793             : Datum
     794           0 : gtsvector_consistent_oldsig(PG_FUNCTION_ARGS)
     795             : {
     796           0 :     return gtsvector_consistent(fcinfo);
     797             : }
     798             : 
     799             : Datum
     800          72 : gtsvector_options(PG_FUNCTION_ARGS)
     801             : {
     802          72 :     local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
     803             : 
     804          72 :     init_local_reloptions(relopts, sizeof(GistTsVectorOptions));
     805          72 :     add_local_int_reloption(relopts, "siglen", "signature length",
     806             :                             SIGLEN_DEFAULT, 1, SIGLEN_MAX,
     807             :                             offsetof(GistTsVectorOptions, siglen));
     808             : 
     809          72 :     PG_RETURN_VOID();
     810             : }

Generated by: LCOV version 1.13