LCOV - code coverage report
Current view: top level - contrib/ltree - ltree_gist.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 362 387 93.5 %
Date: 2024-05-19 08:10:29 Functions: 31 33 93.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * GiST support for ltree
       3             :  * Teodor Sigaev <teodor@stack.net>
       4             :  * contrib/ltree/ltree_gist.c
       5             :  */
       6             : #include "postgres.h"
       7             : 
       8             : #include "access/gist.h"
       9             : #include "access/reloptions.h"
      10             : #include "access/stratnum.h"
      11             : #include "crc32.h"
      12             : #include "ltree.h"
      13             : #include "utils/array.h"
      14             : 
      15             : #define NEXTVAL(x) ( (lquery*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
      16             : #define ISEQ(a,b)   ( (a)->numlevel == (b)->numlevel && ltree_compare(a,b)==0 )
      17             : 
      18           4 : PG_FUNCTION_INFO_V1(ltree_gist_in);
      19           4 : PG_FUNCTION_INFO_V1(ltree_gist_out);
      20             : 
      21             : Datum
      22           0 : ltree_gist_in(PG_FUNCTION_ARGS)
      23             : {
      24           0 :     ereport(ERROR,
      25             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      26             :              errmsg("cannot accept a value of type %s", "ltree_gist")));
      27             : 
      28             :     PG_RETURN_VOID();           /* keep compiler quiet */
      29             : }
      30             : 
      31             : Datum
      32           0 : ltree_gist_out(PG_FUNCTION_ARGS)
      33             : {
      34           0 :     ereport(ERROR,
      35             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      36             :              errmsg("cannot display a value of type %s", "ltree_gist")));
      37             : 
      38             :     PG_RETURN_VOID();           /* keep compiler quiet */
      39             : }
      40             : 
      41             : ltree_gist *
      42       33968 : ltree_gist_alloc(bool isalltrue, BITVECP sign, int siglen,
      43             :                  ltree *left, ltree *right)
      44             : {
      45       44526 :     int32       size = LTG_HDRSIZE + (isalltrue ? 0 : siglen) +
      46       10558 :         (left ? VARSIZE(left) + (right ? VARSIZE(right) : 0) : 0);
      47       33968 :     ltree_gist *result = palloc(size);
      48             : 
      49       33968 :     SET_VARSIZE(result, size);
      50             : 
      51       33968 :     if (siglen)
      52             :     {
      53       29944 :         result->flag = 0;
      54             : 
      55       29944 :         if (isalltrue)
      56           0 :             result->flag |= LTG_ALLTRUE;
      57       29944 :         else if (sign)
      58       10062 :             memcpy(LTG_SIGN(result), sign, siglen);
      59             :         else
      60       19882 :             memset(LTG_SIGN(result), 0, siglen);
      61             : 
      62       29944 :         if (left)
      63             :         {
      64        6534 :             memcpy(LTG_LNODE(result, siglen), left, VARSIZE(left));
      65             : 
      66        6534 :             if (!right || left == right || ISEQ(left, right))
      67           0 :                 result->flag |= LTG_NORIGHT;
      68             :             else
      69        6534 :                 memcpy(LTG_RNODE(result, siglen), right, VARSIZE(right));
      70             :         }
      71             :     }
      72             :     else
      73             :     {
      74             :         Assert(left);
      75        4024 :         result->flag = LTG_ONENODE;
      76        4024 :         memcpy(LTG_NODE(result), left, VARSIZE(left));
      77             :     }
      78             : 
      79       33968 :     return result;
      80             : }
      81             : 
      82           6 : PG_FUNCTION_INFO_V1(ltree_compress);
      83           6 : PG_FUNCTION_INFO_V1(ltree_decompress);
      84           6 : PG_FUNCTION_INFO_V1(ltree_same);
      85           6 : PG_FUNCTION_INFO_V1(ltree_union);
      86           6 : PG_FUNCTION_INFO_V1(ltree_penalty);
      87           6 : PG_FUNCTION_INFO_V1(ltree_picksplit);
      88           6 : PG_FUNCTION_INFO_V1(ltree_consistent);
      89           6 : PG_FUNCTION_INFO_V1(ltree_gist_options);
      90             : 
      91             : #define GETENTRY(vec,pos) ((ltree_gist *) DatumGetPointer((vec)->vector[(pos)].key))
      92             : 
      93             : Datum
      94        4210 : ltree_compress(PG_FUNCTION_ARGS)
      95             : {
      96        4210 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
      97        4210 :     GISTENTRY  *retval = entry;
      98             : 
      99        4210 :     if (entry->leafkey)
     100             :     {                           /* ltree */
     101        4024 :         ltree      *val = DatumGetLtreeP(entry->key);
     102        4024 :         ltree_gist *key = ltree_gist_alloc(false, NULL, 0, val, 0);
     103             : 
     104        4024 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     105        4024 :         gistentryinit(*retval, PointerGetDatum(key),
     106             :                       entry->rel, entry->page,
     107             :                       entry->offset, false);
     108             :     }
     109        4210 :     PG_RETURN_POINTER(retval);
     110             : }
     111             : 
     112             : Datum
     113      195494 : ltree_decompress(PG_FUNCTION_ARGS)
     114             : {
     115      195494 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     116      195494 :     ltree_gist *key = (ltree_gist *) PG_DETOAST_DATUM(entry->key);
     117             : 
     118      195494 :     if (PointerGetDatum(key) != entry->key)
     119             :     {
     120           0 :         GISTENTRY  *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     121             : 
     122           0 :         gistentryinit(*retval, PointerGetDatum(key),
     123             :                       entry->rel, entry->page,
     124             :                       entry->offset, false);
     125           0 :         PG_RETURN_POINTER(retval);
     126             :     }
     127      195494 :     PG_RETURN_POINTER(entry);
     128             : }
     129             : 
     130             : Datum
     131        6398 : ltree_same(PG_FUNCTION_ARGS)
     132             : {
     133        6398 :     ltree_gist *a = (ltree_gist *) PG_GETARG_POINTER(0);
     134        6398 :     ltree_gist *b = (ltree_gist *) PG_GETARG_POINTER(1);
     135        6398 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     136        6398 :     int         siglen = LTREE_GET_SIGLEN();
     137             : 
     138        6398 :     *result = false;
     139        6398 :     if (LTG_ISONENODE(a) != LTG_ISONENODE(b))
     140           0 :         PG_RETURN_POINTER(result);
     141             : 
     142        6398 :     if (LTG_ISONENODE(a))
     143           0 :         *result = ISEQ(LTG_NODE(a), LTG_NODE(b));
     144             :     else
     145             :     {
     146             :         int32       i;
     147        6398 :         BITVECP     sa = LTG_SIGN(a),
     148        6398 :                     sb = LTG_SIGN(b);
     149             : 
     150        6398 :         if (LTG_ISALLTRUE(a) != LTG_ISALLTRUE(b))
     151           0 :             PG_RETURN_POINTER(result);
     152             : 
     153        6398 :         if (!ISEQ(LTG_LNODE(a, siglen), LTG_LNODE(b, siglen)))
     154          20 :             PG_RETURN_POINTER(result);
     155        6378 :         if (!ISEQ(LTG_RNODE(a, siglen), LTG_RNODE(b, siglen)))
     156          26 :             PG_RETURN_POINTER(result);
     157             : 
     158        6352 :         *result = true;
     159        6352 :         if (!LTG_ISALLTRUE(a))
     160             :         {
     161     9213464 :             LOOPBYTE(siglen)
     162             :             {
     163     9207116 :                 if (sa[i] != sb[i])
     164             :                 {
     165           4 :                     *result = false;
     166           4 :                     break;
     167             :                 }
     168             :             }
     169             :         }
     170             :     }
     171             : 
     172        6352 :     PG_RETURN_POINTER(result);
     173             : }
     174             : 
     175             : static void
     176       11544 : hashing(BITVECP sign, ltree *t, int siglen)
     177             : {
     178       11544 :     int         tlen = t->numlevel;
     179       11544 :     ltree_level *cur = LTREE_FIRST(t);
     180             :     int         hash;
     181             : 
     182       87346 :     while (tlen > 0)
     183             :     {
     184       75802 :         hash = ltree_crc32_sz(cur->name, cur->len);
     185       75802 :         HASH(sign, hash, siglen);
     186       75802 :         cur = LEVEL_NEXT(cur);
     187       75802 :         tlen--;
     188             :     }
     189       11544 : }
     190             : 
     191             : Datum
     192        6398 : ltree_union(PG_FUNCTION_ARGS)
     193             : {
     194        6398 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     195        6398 :     int        *size = (int *) PG_GETARG_POINTER(1);
     196        6398 :     int         siglen = LTREE_GET_SIGLEN();
     197        6398 :     BITVECP     base = palloc0(siglen);
     198             :     int32       i,
     199             :                 j;
     200             :     ltree_gist *result,
     201             :                *cur;
     202        6398 :     ltree      *left = NULL,
     203        6398 :                *right = NULL,
     204             :                *curtree;
     205        6398 :     bool        isalltrue = false;
     206             : 
     207       19194 :     for (j = 0; j < entryvec->n; j++)
     208             :     {
     209       12796 :         cur = GETENTRY(entryvec, j);
     210       12796 :         if (LTG_ISONENODE(cur))
     211             :         {
     212        6398 :             curtree = LTG_NODE(cur);
     213        6398 :             hashing(base, curtree, siglen);
     214        6398 :             if (!left || ltree_compare(left, curtree) > 0)
     215          20 :                 left = curtree;
     216        6398 :             if (!right || ltree_compare(right, curtree) < 0)
     217          26 :                 right = curtree;
     218             :         }
     219             :         else
     220             :         {
     221        6398 :             if (isalltrue || LTG_ISALLTRUE(cur))
     222           0 :                 isalltrue = true;
     223             :             else
     224             :             {
     225        6398 :                 BITVECP     sc = LTG_SIGN(cur);
     226             : 
     227     9282798 :                 LOOPBYTE(siglen)
     228     9276400 :                     ((unsigned char *) base)[i] |= sc[i];
     229             :             }
     230             : 
     231        6398 :             curtree = LTG_LNODE(cur, siglen);
     232        6398 :             if (!left || ltree_compare(left, curtree) > 0)
     233        6398 :                 left = curtree;
     234        6398 :             curtree = LTG_RNODE(cur, siglen);
     235        6398 :             if (!right || ltree_compare(right, curtree) < 0)
     236        6398 :                 right = curtree;
     237             :         }
     238             :     }
     239             : 
     240        6398 :     if (isalltrue == false)
     241             :     {
     242        6398 :         isalltrue = true;
     243        6398 :         LOOPBYTE(siglen)
     244             :         {
     245        6398 :             if (((unsigned char *) base)[i] != 0xff)
     246             :             {
     247        6398 :                 isalltrue = false;
     248        6398 :                 break;
     249             :             }
     250             :         }
     251             :     }
     252             : 
     253        6398 :     result = ltree_gist_alloc(isalltrue, base, siglen, left, right);
     254             : 
     255        6398 :     *size = VARSIZE(result);
     256             : 
     257        6398 :     PG_RETURN_POINTER(result);
     258             : }
     259             : 
     260             : Datum
     261       19250 : ltree_penalty(PG_FUNCTION_ARGS)
     262             : {
     263       19250 :     ltree_gist *origval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
     264       19250 :     ltree_gist *newval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
     265       19250 :     float      *penalty = (float *) PG_GETARG_POINTER(2);
     266       19250 :     int         siglen = LTREE_GET_SIGLEN();
     267             :     int32       cmpr,
     268             :                 cmpl;
     269             : 
     270       19250 :     cmpl = ltree_compare(LTG_GETLNODE(origval, siglen), LTG_GETLNODE(newval, siglen));
     271       19250 :     cmpr = ltree_compare(LTG_GETRNODE(newval, siglen), LTG_GETRNODE(origval, siglen));
     272             : 
     273       19250 :     *penalty = Max(cmpl, 0) + Max(cmpr, 0);
     274             : 
     275       19250 :     PG_RETURN_POINTER(penalty);
     276             : }
     277             : 
     278             : /* used for sorting */
     279             : typedef struct rix
     280             : {
     281             :     int         index;
     282             :     ltree      *r;
     283             : } RIX;
     284             : 
     285             : static int
     286       36558 : treekey_cmp(const void *a, const void *b)
     287             : {
     288       73116 :     return ltree_compare(((const RIX *) a)->r,
     289       36558 :                          ((const RIX *) b)->r);
     290             : }
     291             : 
     292             : 
     293             : Datum
     294          68 : ltree_picksplit(PG_FUNCTION_ARGS)
     295             : {
     296          68 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     297          68 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     298          68 :     int         siglen = LTREE_GET_SIGLEN();
     299             :     OffsetNumber j;
     300             :     int32       i;
     301             :     RIX        *array;
     302             :     OffsetNumber maxoff;
     303             :     int         nbytes;
     304             :     ltree      *lu_l,
     305             :                *lu_r,
     306             :                *ru_l,
     307             :                *ru_r;
     308             :     ltree_gist *lu,
     309             :                *ru;
     310          68 :     BITVECP     ls = palloc0(siglen),
     311          68 :                 rs = palloc0(siglen);
     312          68 :     bool        lisat = false,
     313          68 :                 risat = false;
     314             : 
     315          68 :     maxoff = entryvec->n - 1;
     316          68 :     nbytes = (maxoff + 2) * sizeof(OffsetNumber);
     317          68 :     v->spl_left = (OffsetNumber *) palloc(nbytes);
     318          68 :     v->spl_right = (OffsetNumber *) palloc(nbytes);
     319          68 :     v->spl_nleft = 0;
     320          68 :     v->spl_nright = 0;
     321          68 :     array = (RIX *) palloc(sizeof(RIX) * (maxoff + 1));
     322             : 
     323             :     /* copy the data into RIXes, and sort the RIXes */
     324        5262 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     325             :     {
     326        5194 :         array[j].index = j;
     327        5194 :         lu = GETENTRY(entryvec, j); /* use as tmp val */
     328        5194 :         array[j].r = LTG_GETLNODE(lu, siglen);
     329             :     }
     330             : 
     331          68 :     qsort(&array[FirstOffsetNumber], maxoff - FirstOffsetNumber + 1,
     332             :           sizeof(RIX), treekey_cmp);
     333             : 
     334          68 :     lu_l = lu_r = ru_l = ru_r = NULL;
     335        5262 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     336             :     {
     337        5194 :         lu = GETENTRY(entryvec, array[j].index);    /* use as tmp val */
     338        5194 :         if (j <= (maxoff - FirstOffsetNumber + 1) / 2)
     339             :         {
     340        2586 :             v->spl_left[v->spl_nleft] = array[j].index;
     341        2586 :             v->spl_nleft++;
     342        2586 :             if (lu_r == NULL || ltree_compare(LTG_GETRNODE(lu, siglen), lu_r) > 0)
     343        2584 :                 lu_r = LTG_GETRNODE(lu, siglen);
     344        2586 :             if (LTG_ISONENODE(lu))
     345        2562 :                 hashing(ls, LTG_NODE(lu), siglen);
     346             :             else
     347             :             {
     348          24 :                 if (lisat || LTG_ISALLTRUE(lu))
     349           0 :                     lisat = true;
     350             :                 else
     351             :                 {
     352          24 :                     BITVECP     sc = LTG_SIGN(lu);
     353             : 
     354       48600 :                     LOOPBYTE(siglen)
     355       48576 :                         ((unsigned char *) ls)[i] |= sc[i];
     356             :                 }
     357             :             }
     358             :         }
     359             :         else
     360             :         {
     361        2608 :             v->spl_right[v->spl_nright] = array[j].index;
     362        2608 :             v->spl_nright++;
     363        2608 :             if (ru_r == NULL || ltree_compare(LTG_GETRNODE(lu, siglen), ru_r) > 0)
     364        2606 :                 ru_r = LTG_GETRNODE(lu, siglen);
     365        2608 :             if (LTG_ISONENODE(lu))
     366        2584 :                 hashing(rs, LTG_NODE(lu), siglen);
     367             :             else
     368             :             {
     369          24 :                 if (risat || LTG_ISALLTRUE(lu))
     370           0 :                     risat = true;
     371             :                 else
     372             :                 {
     373          24 :                     BITVECP     sc = LTG_SIGN(lu);
     374             : 
     375       48600 :                     LOOPBYTE(siglen)
     376       48576 :                         ((unsigned char *) rs)[i] |= sc[i];
     377             :                 }
     378             :             }
     379             :         }
     380             :     }
     381             : 
     382          68 :     if (lisat == false)
     383             :     {
     384          68 :         lisat = true;
     385          68 :         LOOPBYTE(siglen)
     386             :         {
     387          68 :             if (((unsigned char *) ls)[i] != 0xff)
     388             :             {
     389          68 :                 lisat = false;
     390          68 :                 break;
     391             :             }
     392             :         }
     393             :     }
     394             : 
     395          68 :     if (risat == false)
     396             :     {
     397          68 :         risat = true;
     398          68 :         LOOPBYTE(siglen)
     399             :         {
     400          68 :             if (((unsigned char *) rs)[i] != 0xff)
     401             :             {
     402          68 :                 risat = false;
     403          68 :                 break;
     404             :             }
     405             :         }
     406             :     }
     407             : 
     408          68 :     lu_l = LTG_GETLNODE(GETENTRY(entryvec, array[FirstOffsetNumber].index), siglen);
     409          68 :     lu = ltree_gist_alloc(lisat, ls, siglen, lu_l, lu_r);
     410             : 
     411          68 :     ru_l = LTG_GETLNODE(GETENTRY(entryvec, array[1 + ((maxoff - FirstOffsetNumber + 1) / 2)].index), siglen);
     412          68 :     ru = ltree_gist_alloc(risat, rs, siglen, ru_l, ru_r);
     413             : 
     414          68 :     pfree(ls);
     415          68 :     pfree(rs);
     416             : 
     417          68 :     v->spl_ldatum = PointerGetDatum(lu);
     418          68 :     v->spl_rdatum = PointerGetDatum(ru);
     419             : 
     420          68 :     PG_RETURN_POINTER(v);
     421             : }
     422             : 
     423             : static bool
     424          46 : gist_isparent(ltree_gist *key, ltree *query, int siglen)
     425             : {
     426          46 :     int32       numlevel = query->numlevel;
     427             :     int         i;
     428             : 
     429         198 :     for (i = query->numlevel; i >= 0; i--)
     430             :     {
     431         160 :         query->numlevel = i;
     432         168 :         if (ltree_compare(query, LTG_GETLNODE(key, siglen)) >= 0 &&
     433           8 :             ltree_compare(query, LTG_GETRNODE(key, siglen)) <= 0)
     434             :         {
     435           8 :             query->numlevel = numlevel;
     436           8 :             return true;
     437             :         }
     438             :     }
     439             : 
     440          38 :     query->numlevel = numlevel;
     441          38 :     return false;
     442             : }
     443             : 
     444             : static ltree *
     445          92 : copy_ltree(ltree *src)
     446             : {
     447          92 :     ltree      *dst = (ltree *) palloc0(VARSIZE(src));
     448             : 
     449          92 :     memcpy(dst, src, VARSIZE(src));
     450          92 :     return dst;
     451             : }
     452             : 
     453             : static bool
     454          46 : gist_ischild(ltree_gist *key, ltree *query, int siglen)
     455             : {
     456          46 :     ltree      *left = copy_ltree(LTG_GETLNODE(key, siglen));
     457          46 :     ltree      *right = copy_ltree(LTG_GETRNODE(key, siglen));
     458          46 :     bool        res = true;
     459             : 
     460          46 :     if (left->numlevel > query->numlevel)
     461          34 :         left->numlevel = query->numlevel;
     462             : 
     463          46 :     if (ltree_compare(query, left) < 0)
     464          38 :         res = false;
     465             : 
     466          46 :     if (right->numlevel > query->numlevel)
     467          38 :         right->numlevel = query->numlevel;
     468             : 
     469          46 :     if (res && ltree_compare(query, right) > 0)
     470           0 :         res = false;
     471             : 
     472          46 :     pfree(left);
     473          46 :     pfree(right);
     474             : 
     475          46 :     return res;
     476             : }
     477             : 
     478             : static bool
     479         406 : gist_qe(ltree_gist *key, lquery *query, int siglen)
     480             : {
     481         406 :     lquery_level *curq = LQUERY_FIRST(query);
     482         406 :     BITVECP     sign = LTG_SIGN(key);
     483         406 :     int         qlen = query->numlevel;
     484             : 
     485         406 :     if (LTG_ISALLTRUE(key))
     486           0 :         return true;
     487             : 
     488        1594 :     while (qlen > 0)
     489             :     {
     490        1188 :         if (curq->numvar && LQL_CANLOOKSIGN(curq))
     491             :         {
     492         782 :             bool        isexist = false;
     493         782 :             int         vlen = curq->numvar;
     494         782 :             lquery_variant *curv = LQL_FIRST(curq);
     495             : 
     496         782 :             while (vlen > 0)
     497             :             {
     498         782 :                 if (GETBIT(sign, HASHVAL(curv->val, siglen)))
     499             :                 {
     500         782 :                     isexist = true;
     501         782 :                     break;
     502             :                 }
     503           0 :                 curv = LVAR_NEXT(curv);
     504           0 :                 vlen--;
     505             :             }
     506         782 :             if (!isexist)
     507           0 :                 return false;
     508             :         }
     509             : 
     510        1188 :         curq = LQL_NEXT(curq);
     511        1188 :         qlen--;
     512             :     }
     513             : 
     514         406 :     return true;
     515             : }
     516             : 
     517             : static int
     518         532 : gist_tqcmp(ltree *t, lquery *q)
     519             : {
     520         532 :     ltree_level *al = LTREE_FIRST(t);
     521         532 :     lquery_level *ql = LQUERY_FIRST(q);
     522             :     lquery_variant *bl;
     523         532 :     int         an = t->numlevel;
     524         532 :     int         bn = q->firstgood;
     525         532 :     int         res = 0;
     526             : 
     527         628 :     while (an > 0 && bn > 0)
     528             :     {
     529         496 :         bl = LQL_FIRST(ql);
     530         496 :         if ((res = memcmp(al->name, bl->name, Min(al->len, bl->len))) == 0)
     531             :         {
     532         166 :             if (al->len != bl->len)
     533          70 :                 return al->len - bl->len;
     534             :         }
     535             :         else
     536         330 :             return res;
     537          96 :         an--;
     538          96 :         bn--;
     539          96 :         al = LEVEL_NEXT(al);
     540          96 :         ql = LQL_NEXT(ql);
     541             :     }
     542             : 
     543         132 :     return Min(t->numlevel, q->firstgood) - q->firstgood;
     544             : }
     545             : 
     546             : static bool
     547         406 : gist_between(ltree_gist *key, lquery *query, int siglen)
     548             : {
     549         406 :     if (query->firstgood == 0)
     550          76 :         return true;
     551             : 
     552         330 :     if (gist_tqcmp(LTG_GETLNODE(key, siglen), query) > 0)
     553         128 :         return false;
     554             : 
     555         202 :     if (gist_tqcmp(LTG_GETRNODE(key, siglen), query) < 0)
     556          90 :         return false;
     557             : 
     558         112 :     return true;
     559             : }
     560             : 
     561             : typedef struct LtreeSignature
     562             : {
     563             :     BITVECP     sign;
     564             :     int         siglen;
     565             : } LtreeSignature;
     566             : 
     567             : static bool
     568         152 : checkcondition_bit(void *cxt, ITEM *val)
     569             : {
     570         152 :     LtreeSignature *sig = cxt;
     571             : 
     572         152 :     return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(sig->sign, HASHVAL(val->val, sig->siglen)) : true;
     573             : }
     574             : 
     575             : static bool
     576          76 : gist_qtxt(ltree_gist *key, ltxtquery *query, int siglen)
     577             : {
     578             :     LtreeSignature sig;
     579             : 
     580          76 :     if (LTG_ISALLTRUE(key))
     581           0 :         return true;
     582             : 
     583          76 :     sig.sign = LTG_SIGN(key);
     584          76 :     sig.siglen = siglen;
     585             : 
     586          76 :     return ltree_execute(GETQUERY(query),
     587             :                          &sig, false,
     588             :                          checkcondition_bit);
     589             : }
     590             : 
     591             : static bool
     592          62 : arrq_cons(ltree_gist *key, ArrayType *_query, int siglen)
     593             : {
     594          62 :     lquery     *query = (lquery *) ARR_DATA_PTR(_query);
     595          62 :     int         num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
     596             : 
     597          62 :     if (ARR_NDIM(_query) > 1)
     598           0 :         ereport(ERROR,
     599             :                 (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     600             :                  errmsg("array must be one-dimensional")));
     601          62 :     if (array_contains_nulls(_query))
     602           0 :         ereport(ERROR,
     603             :                 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
     604             :                  errmsg("array must not contain nulls")));
     605             : 
     606         134 :     while (num > 0)
     607             :     {
     608          98 :         if (gist_qe(key, query, siglen) && gist_between(key, query, siglen))
     609          26 :             return true;
     610          72 :         num--;
     611          72 :         query = NEXTVAL(query);
     612             :     }
     613          36 :     return false;
     614             : }
     615             : 
     616             : Datum
     617       19824 : ltree_consistent(PG_FUNCTION_ARGS)
     618             : {
     619       19824 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     620       19824 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     621             : 
     622             :     /* Oid      subtype = PG_GETARG_OID(3); */
     623       19824 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     624       19824 :     int         siglen = LTREE_GET_SIGLEN();
     625       19824 :     ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
     626       19824 :     void       *query = NULL;
     627       19824 :     bool        res = false;
     628             : 
     629             :     /* All cases served by this function are exact */
     630       19824 :     *recheck = false;
     631             : 
     632       19824 :     switch (strategy)
     633             :     {
     634         672 :         case BTLessStrategyNumber:
     635         672 :             query = PG_GETARG_LTREE_P(1);
     636         672 :             res = (GIST_LEAF(entry)) ?
     637         642 :                 (ltree_compare((ltree *) query, LTG_NODE(key)) > 0)
     638        1344 :                 :
     639          30 :                 (ltree_compare((ltree *) query, LTG_GETLNODE(key, siglen)) >= 0);
     640         672 :             break;
     641         672 :         case BTLessEqualStrategyNumber:
     642         672 :             query = PG_GETARG_LTREE_P(1);
     643         672 :             res = (ltree_compare((ltree *) query, LTG_GETLNODE(key, siglen)) >= 0);
     644         672 :             break;
     645         634 :         case BTEqualStrategyNumber:
     646         634 :             query = PG_GETARG_LTREE_P(1);
     647         634 :             if (GIST_LEAF(entry))
     648         588 :                 res = (ltree_compare((ltree *) query, LTG_NODE(key)) == 0);
     649             :             else
     650          92 :                 res = (ltree_compare((ltree *) query, LTG_GETLNODE(key, siglen)) >= 0
     651          62 :                        &&
     652          16 :                        ltree_compare((ltree *) query, LTG_GETRNODE(key, siglen)) <= 0);
     653         634 :             break;
     654        1878 :         case BTGreaterEqualStrategyNumber:
     655        1878 :             query = PG_GETARG_LTREE_P(1);
     656        1878 :             res = (ltree_compare((ltree *) query, LTG_GETRNODE(key, siglen)) <= 0);
     657        1878 :             break;
     658        1878 :         case BTGreaterStrategyNumber:
     659        1878 :             query = PG_GETARG_LTREE_P(1);
     660        1878 :             res = (GIST_LEAF(entry)) ?
     661        1848 :                 (ltree_compare((ltree *) query, LTG_GETRNODE(key, siglen)) < 0)
     662        3756 :                 :
     663          30 :                 (ltree_compare((ltree *) query, LTG_GETRNODE(key, siglen)) <= 0);
     664        1878 :             break;
     665         374 :         case 10:
     666         374 :             query = PG_GETARG_LTREE_P_COPY(1);
     667         374 :             res = (GIST_LEAF(entry)) ?
     668         328 :                 inner_isparent((ltree *) query, LTG_NODE(key))
     669         702 :                 :
     670          46 :                 gist_isparent(key, (ltree *) query, siglen);
     671         374 :             break;
     672         374 :         case 11:
     673         374 :             query = PG_GETARG_LTREE_P(1);
     674         374 :             res = (GIST_LEAF(entry)) ?
     675         328 :                 inner_isparent(LTG_NODE(key), (ltree *) query)
     676         702 :                 :
     677          46 :                 gist_ischild(key, (ltree *) query, siglen);
     678         374 :             break;
     679        8050 :         case 12:
     680             :         case 13:
     681        8050 :             query = PG_GETARG_LQUERY_P(1);
     682        8050 :             if (GIST_LEAF(entry))
     683        7742 :                 res = DatumGetBool(DirectFunctionCall2(ltq_regex,
     684             :                                                        PointerGetDatum(LTG_NODE(key)),
     685             :                                                        PointerGetDatum((lquery *) query)
     686             :                                                        ));
     687             :             else
     688         616 :                 res = (gist_qe(key, (lquery *) query, siglen) &&
     689         308 :                        gist_between(key, (lquery *) query, siglen));
     690        8050 :             break;
     691        4100 :         case 14:
     692             :         case 15:
     693        4100 :             query = PG_GETARG_LTXTQUERY_P(1);
     694        4100 :             if (GIST_LEAF(entry))
     695        4024 :                 res = DatumGetBool(DirectFunctionCall2(ltxtq_exec,
     696             :                                                        PointerGetDatum(LTG_NODE(key)),
     697             :                                                        PointerGetDatum((ltxtquery *) query)
     698             :                                                        ));
     699             :             else
     700          76 :                 res = gist_qtxt(key, (ltxtquery *) query, siglen);
     701        4100 :             break;
     702        1192 :         case 16:
     703             :         case 17:
     704        1192 :             query = PG_GETARG_ARRAYTYPE_P(1);
     705        1192 :             if (GIST_LEAF(entry))
     706        1130 :                 res = DatumGetBool(DirectFunctionCall2(lt_q_regex,
     707             :                                                        PointerGetDatum(LTG_NODE(key)),
     708             :                                                        PointerGetDatum((ArrayType *) query)
     709             :                                                        ));
     710             :             else
     711          62 :                 res = arrq_cons(key, (ArrayType *) query, siglen);
     712        1192 :             break;
     713           0 :         default:
     714             :             /* internal error */
     715           0 :             elog(ERROR, "unrecognized StrategyNumber: %d", strategy);
     716             :     }
     717             : 
     718       19824 :     PG_FREE_IF_COPY(query, 1);
     719       19824 :     PG_RETURN_BOOL(res);
     720             : }
     721             : 
     722             : static void
     723           6 : ltree_gist_relopts_validator(void *parsed_options, relopt_value *vals,
     724             :                              int nvals)
     725             : {
     726           6 :     LtreeGistOptions *options = (LtreeGistOptions *) parsed_options;
     727             : 
     728           6 :     if (options->siglen != INTALIGN(options->siglen))
     729           2 :         ereport(ERROR,
     730             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     731             :                  errmsg("siglen value must be a multiple of %d", ALIGNOF_INT)));
     732           4 : }
     733             : 
     734             : Datum
     735          28 : ltree_gist_options(PG_FUNCTION_ARGS)
     736             : {
     737          28 :     local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
     738             : 
     739          28 :     init_local_reloptions(relopts, sizeof(LtreeGistOptions));
     740          28 :     add_local_int_reloption(relopts, "siglen",
     741             :                             "signature length in bytes",
     742             :                             LTREE_SIGLEN_DEFAULT,
     743             :                             INTALIGN(1),
     744             :                             LTREE_SIGLEN_MAX,
     745             :                             offsetof(LtreeGistOptions, siglen));
     746          28 :     register_reloptions_validator(relopts, ltree_gist_relopts_validator);
     747             : 
     748          28 :     PG_RETURN_VOID();
     749             : }

Generated by: LCOV version 1.14