LCOV - code coverage report
Current view: top level - contrib/intarray - _intbig_gist.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 250 281 89.0 %
Date: 2020-06-05 19:06:29 Functions: 25 28 89.3 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * contrib/intarray/_intbig_gist.c
       3             :  */
       4             : #include "postgres.h"
       5             : 
       6             : #include "_int.h"
       7             : #include "access/gist.h"
       8             : #include "access/reloptions.h"
       9             : #include "access/stratnum.h"
      10             : #include "port/pg_bitutils.h"
      11             : 
      12             : #define GETENTRY(vec,pos) ((GISTTYPE *) DatumGetPointer((vec)->vector[(pos)].key))
      13             : /*
      14             : ** _intbig methods
      15             : */
      16           4 : PG_FUNCTION_INFO_V1(g_intbig_consistent);
      17           4 : PG_FUNCTION_INFO_V1(g_intbig_compress);
      18           4 : PG_FUNCTION_INFO_V1(g_intbig_decompress);
      19           4 : PG_FUNCTION_INFO_V1(g_intbig_penalty);
      20           4 : PG_FUNCTION_INFO_V1(g_intbig_picksplit);
      21           4 : PG_FUNCTION_INFO_V1(g_intbig_union);
      22           4 : PG_FUNCTION_INFO_V1(g_intbig_same);
      23           4 : PG_FUNCTION_INFO_V1(g_intbig_options);
      24             : 
      25           2 : PG_FUNCTION_INFO_V1(_intbig_in);
      26           2 : PG_FUNCTION_INFO_V1(_intbig_out);
      27             : 
      28             : Datum
      29           0 : _intbig_in(PG_FUNCTION_ARGS)
      30             : {
      31           0 :     ereport(ERROR,
      32             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      33             :              errmsg("_intbig_in() not implemented")));
      34             :     PG_RETURN_DATUM(0);
      35             : }
      36             : 
      37             : Datum
      38           0 : _intbig_out(PG_FUNCTION_ARGS)
      39             : {
      40           0 :     ereport(ERROR,
      41             :             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
      42             :              errmsg("_intbig_out() not implemented")));
      43             :     PG_RETURN_DATUM(0);
      44             : }
      45             : 
      46             : static GISTTYPE *
      47      174306 : _intbig_alloc(bool allistrue, int siglen, BITVECP sign)
      48             : {
      49      174306 :     int         flag = allistrue ? ALLISTRUE : 0;
      50      174306 :     int         size = CALCGTSIZE(flag, siglen);
      51      174306 :     GISTTYPE   *res = (GISTTYPE *) palloc(size);
      52             : 
      53      174306 :     SET_VARSIZE(res, size);
      54      174306 :     res->flag = flag;
      55             : 
      56      174306 :     if (!allistrue)
      57             :     {
      58      174306 :         if (sign)
      59       18032 :             memcpy(GETSIGN(res), sign, siglen);
      60             :         else
      61      156274 :             memset(GETSIGN(res), 0, siglen);
      62             :     }
      63             : 
      64      174306 :     return res;
      65             : }
      66             : 
      67             : 
      68             : /*********************************************************************
      69             : ** intbig functions
      70             : *********************************************************************/
      71             : static bool
      72       15004 : _intbig_overlap(GISTTYPE *a, ArrayType *b, int siglen)
      73             : {
      74       15004 :     int         num = ARRNELEMS(b);
      75       15004 :     int32      *ptr = ARRPTR(b);
      76             : 
      77       15004 :     CHECKARRVALID(b);
      78             : 
      79       38484 :     while (num--)
      80             :     {
      81       27616 :         if (GETBIT(GETSIGN(a), HASHVAL(*ptr, siglen)))
      82        4136 :             return true;
      83       23480 :         ptr++;
      84             :     }
      85             : 
      86       10868 :     return false;
      87             : }
      88             : 
      89             : static bool
      90       19654 : _intbig_contains(GISTTYPE *a, ArrayType *b, int siglen)
      91             : {
      92       19654 :     int         num = ARRNELEMS(b);
      93       19654 :     int32      *ptr = ARRPTR(b);
      94             : 
      95       19654 :     CHECKARRVALID(b);
      96             : 
      97       28978 :     while (num--)
      98             :     {
      99       25918 :         if (!GETBIT(GETSIGN(a), HASHVAL(*ptr, siglen)))
     100       16594 :             return false;
     101        9324 :         ptr++;
     102             :     }
     103             : 
     104        3060 :     return true;
     105             : }
     106             : 
     107             : Datum
     108      128408 : g_intbig_same(PG_FUNCTION_ARGS)
     109             : {
     110      128408 :     GISTTYPE   *a = (GISTTYPE *) PG_GETARG_POINTER(0);
     111      128408 :     GISTTYPE   *b = (GISTTYPE *) PG_GETARG_POINTER(1);
     112      128408 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
     113      128408 :     int         siglen = GET_SIGLEN();
     114             : 
     115      128408 :     if (ISALLTRUE(a) && ISALLTRUE(b))
     116           0 :         *result = true;
     117      128408 :     else if (ISALLTRUE(a))
     118           0 :         *result = false;
     119      128408 :     else if (ISALLTRUE(b))
     120           0 :         *result = false;
     121             :     else
     122             :     {
     123             :         int32       i;
     124      128408 :         BITVECP     sa = GETSIGN(a),
     125      128408 :                     sb = GETSIGN(b);
     126             : 
     127      128408 :         *result = true;
     128    97404544 :         LOOPBYTE(siglen)
     129             :         {
     130    97345510 :             if (sa[i] != sb[i])
     131             :             {
     132       69374 :                 *result = false;
     133       69374 :                 break;
     134             :             }
     135             :         }
     136             :     }
     137      128408 :     PG_RETURN_POINTER(result);
     138             : }
     139             : 
     140             : Datum
     141      114434 : g_intbig_compress(PG_FUNCTION_ARGS)
     142             : {
     143      114434 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     144      114434 :     int         siglen = GET_SIGLEN();
     145             : 
     146      114434 :     if (entry->leafkey)
     147             :     {
     148             :         GISTENTRY  *retval;
     149       27024 :         ArrayType  *in = DatumGetArrayTypeP(entry->key);
     150             :         int32      *ptr;
     151             :         int         num;
     152       27024 :         GISTTYPE   *res = _intbig_alloc(false, siglen, NULL);
     153             : 
     154       27024 :         CHECKARRVALID(in);
     155       27024 :         if (ARRISEMPTY(in))
     156             :         {
     157          36 :             ptr = NULL;
     158          36 :             num = 0;
     159             :         }
     160             :         else
     161             :         {
     162       26988 :             ptr = ARRPTR(in);
     163       26988 :             num = ARRNELEMS(in);
     164             :         }
     165             : 
     166      135612 :         while (num--)
     167             :         {
     168      108588 :             HASH(GETSIGN(res), *ptr, siglen);
     169      108588 :             ptr++;
     170             :         }
     171             : 
     172       27024 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     173       27024 :         gistentryinit(*retval, PointerGetDatum(res),
     174             :                       entry->rel, entry->page,
     175             :                       entry->offset, false);
     176             : 
     177       27024 :         if (in != DatumGetArrayTypeP(entry->key))
     178       27024 :             pfree(in);
     179             : 
     180       27024 :         PG_RETURN_POINTER(retval);
     181             :     }
     182       87410 :     else if (!ISALLTRUE(DatumGetPointer(entry->key)))
     183             :     {
     184             :         GISTENTRY  *retval;
     185             :         int         i;
     186       87410 :         BITVECP     sign = GETSIGN(DatumGetPointer(entry->key));
     187             :         GISTTYPE   *res;
     188             : 
     189      113382 :         LOOPBYTE(siglen)
     190             :         {
     191      113382 :             if ((sign[i] & 0xff) != 0xff)
     192       87410 :                 PG_RETURN_POINTER(entry);
     193             :         }
     194             : 
     195           0 :         res = _intbig_alloc(true, siglen, sign);
     196           0 :         retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
     197           0 :         gistentryinit(*retval, PointerGetDatum(res),
     198             :                       entry->rel, entry->page,
     199             :                       entry->offset, false);
     200             : 
     201           0 :         PG_RETURN_POINTER(retval);
     202             :     }
     203             : 
     204           0 :     PG_RETURN_POINTER(entry);
     205             : }
     206             : 
     207             : 
     208             : static int32
     209           0 : sizebitvec(BITVECP sign, int siglen)
     210             : {
     211           0 :     return pg_popcount(sign, siglen);
     212             : }
     213             : 
     214             : static int
     215      998196 : hemdistsign(BITVECP a, BITVECP b, int siglen)
     216             : {
     217             :     int         i,
     218             :                 diff,
     219      998196 :                 dist = 0;
     220             : 
     221   902970364 :     LOOPBYTE(siglen)
     222             :     {
     223   901972168 :         diff = (unsigned char) (a[i] ^ b[i]);
     224             :         /* Using the popcount functions here isn't likely to win */
     225   901972168 :         dist += pg_number_of_ones[diff];
     226             :     }
     227      998196 :     return dist;
     228             : }
     229             : 
     230             : static int
     231      998196 : hemdist(GISTTYPE *a, GISTTYPE *b, int siglen)
     232             : {
     233      998196 :     if (ISALLTRUE(a))
     234             :     {
     235           0 :         if (ISALLTRUE(b))
     236           0 :             return 0;
     237             :         else
     238           0 :             return SIGLENBIT(siglen) - sizebitvec(GETSIGN(b), siglen);
     239             :     }
     240      998196 :     else if (ISALLTRUE(b))
     241           0 :         return SIGLENBIT(siglen) - sizebitvec(GETSIGN(a), siglen);
     242             : 
     243      998196 :     return hemdistsign(GETSIGN(a), GETSIGN(b), siglen);
     244             : }
     245             : 
     246             : Datum
     247     1219592 : g_intbig_decompress(PG_FUNCTION_ARGS)
     248             : {
     249     1219592 :     PG_RETURN_DATUM(PG_GETARG_DATUM(0));
     250             : }
     251             : 
     252             : static int32
     253      258720 : unionkey(BITVECP sbase, GISTTYPE *add, int siglen)
     254             : {
     255             :     int32       i;
     256      258720 :     BITVECP     sadd = GETSIGN(add);
     257             : 
     258      258720 :     if (ISALLTRUE(add))
     259           0 :         return 1;
     260   432479888 :     LOOPBYTE(siglen)
     261   432221168 :         sbase[i] |= sadd[i];
     262      258720 :     return 0;
     263             : }
     264             : 
     265             : Datum
     266      129250 : g_intbig_union(PG_FUNCTION_ARGS)
     267             : {
     268      129250 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     269      129250 :     int        *size = (int *) PG_GETARG_POINTER(1);
     270      129250 :     int         siglen = GET_SIGLEN();
     271             :     int32       i;
     272      129250 :     GISTTYPE   *result = _intbig_alloc(false, siglen, NULL);
     273      129250 :     BITVECP     base = GETSIGN(result);
     274             : 
     275      387970 :     for (i = 0; i < entryvec->n; i++)
     276             :     {
     277      258720 :         if (unionkey(base, GETENTRY(entryvec, i), siglen))
     278             :         {
     279           0 :             result->flag |= ALLISTRUE;
     280           0 :             SET_VARSIZE(result, CALCGTSIZE(ALLISTRUE, siglen));
     281           0 :             break;
     282             :         }
     283             :     }
     284             : 
     285      129250 :     *size = VARSIZE(result);
     286             : 
     287      129250 :     PG_RETURN_POINTER(result);
     288             : }
     289             : 
     290             : Datum
     291      602904 : g_intbig_penalty(PG_FUNCTION_ARGS)
     292             : {
     293      602904 :     GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
     294      602904 :     GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
     295      602904 :     float      *penalty = (float *) PG_GETARG_POINTER(2);
     296      602904 :     GISTTYPE   *origval = (GISTTYPE *) DatumGetPointer(origentry->key);
     297      602904 :     GISTTYPE   *newval = (GISTTYPE *) DatumGetPointer(newentry->key);
     298      602904 :     int         siglen = GET_SIGLEN();
     299             : 
     300      602904 :     *penalty = hemdist(origval, newval, siglen);
     301      602904 :     PG_RETURN_POINTER(penalty);
     302             : }
     303             : 
     304             : 
     305             : typedef struct
     306             : {
     307             :     OffsetNumber pos;
     308             :     int32       cost;
     309             : } SPLITCOST;
     310             : 
     311             : static int
     312       79486 : comparecost(const void *a, const void *b)
     313             : {
     314       79486 :     return ((const SPLITCOST *) a)->cost - ((const SPLITCOST *) b)->cost;
     315             : }
     316             : 
     317             : 
     318             : Datum
     319        9016 : g_intbig_picksplit(PG_FUNCTION_ARGS)
     320             : {
     321        9016 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     322        9016 :     GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
     323        9016 :     int         siglen = GET_SIGLEN();
     324             :     OffsetNumber k,
     325             :                 j;
     326             :     GISTTYPE   *datum_l,
     327             :                *datum_r;
     328             :     BITVECP     union_l,
     329             :                 union_r;
     330             :     int32       size_alpha,
     331             :                 size_beta;
     332             :     int32       size_waste,
     333        9016 :                 waste = -1;
     334             :     int32       nbytes;
     335        9016 :     OffsetNumber seed_1 = 0,
     336        9016 :                 seed_2 = 0;
     337             :     OffsetNumber *left,
     338             :                *right;
     339             :     OffsetNumber maxoff;
     340             :     BITVECP     ptr;
     341             :     int         i;
     342             :     SPLITCOST  *costvector;
     343             :     GISTTYPE   *_k,
     344             :                *_j;
     345             : 
     346        9016 :     maxoff = entryvec->n - 2;
     347        9016 :     nbytes = (maxoff + 2) * sizeof(OffsetNumber);
     348        9016 :     v->spl_left = (OffsetNumber *) palloc(nbytes);
     349        9016 :     v->spl_right = (OffsetNumber *) palloc(nbytes);
     350             : 
     351       41494 :     for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
     352             :     {
     353       32478 :         _k = GETENTRY(entryvec, k);
     354      261794 :         for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
     355             :         {
     356      229316 :             size_waste = hemdist(_k, GETENTRY(entryvec, j), siglen);
     357      229316 :             if (size_waste > waste)
     358             :             {
     359       17752 :                 waste = size_waste;
     360       17752 :                 seed_1 = k;
     361       17752 :                 seed_2 = j;
     362             :             }
     363             :         }
     364             :     }
     365             : 
     366        9016 :     left = v->spl_left;
     367        9016 :     v->spl_nleft = 0;
     368        9016 :     right = v->spl_right;
     369        9016 :     v->spl_nright = 0;
     370             : 
     371        9016 :     if (seed_1 == 0 || seed_2 == 0)
     372             :     {
     373           0 :         seed_1 = 1;
     374           0 :         seed_2 = 2;
     375             :     }
     376             : 
     377             :     /* form initial .. */
     378        9016 :     datum_l = _intbig_alloc(ISALLTRUE(GETENTRY(entryvec, seed_1)), siglen,
     379        9016 :                             GETSIGN(GETENTRY(entryvec, seed_1)));
     380        9016 :     datum_r = _intbig_alloc(ISALLTRUE(GETENTRY(entryvec, seed_2)), siglen,
     381        9016 :                             GETSIGN(GETENTRY(entryvec, seed_2)));
     382             : 
     383        9016 :     maxoff = OffsetNumberNext(maxoff);
     384             :     /* sort before ... */
     385        9016 :     costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
     386       59526 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     387             :     {
     388       50510 :         costvector[j - 1].pos = j;
     389       50510 :         _j = GETENTRY(entryvec, j);
     390       50510 :         size_alpha = hemdist(datum_l, _j, siglen);
     391       50510 :         size_beta = hemdist(datum_r, _j, siglen);
     392       50510 :         costvector[j - 1].cost = Abs(size_alpha - size_beta);
     393             :     }
     394        9016 :     qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
     395             : 
     396        9016 :     union_l = GETSIGN(datum_l);
     397        9016 :     union_r = GETSIGN(datum_r);
     398             : 
     399       59526 :     for (k = 0; k < maxoff; k++)
     400             :     {
     401       50510 :         j = costvector[k].pos;
     402       50510 :         if (j == seed_1)
     403             :         {
     404        9016 :             *left++ = j;
     405        9016 :             v->spl_nleft++;
     406        9016 :             continue;
     407             :         }
     408       41494 :         else if (j == seed_2)
     409             :         {
     410        9016 :             *right++ = j;
     411        9016 :             v->spl_nright++;
     412        9016 :             continue;
     413             :         }
     414       32478 :         _j = GETENTRY(entryvec, j);
     415       32478 :         size_alpha = hemdist(datum_l, _j, siglen);
     416       32478 :         size_beta = hemdist(datum_r, _j, siglen);
     417             : 
     418       32478 :         if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001))
     419             :         {
     420       16146 :             if (ISALLTRUE(datum_l) || ISALLTRUE(_j))
     421             :             {
     422           0 :                 if (!ISALLTRUE(datum_l))
     423           0 :                     MemSet((void *) union_l, 0xff, siglen);
     424             :             }
     425             :             else
     426             :             {
     427       16146 :                 ptr = GETSIGN(_j);
     428    18523194 :                 LOOPBYTE(siglen)
     429    18507048 :                     union_l[i] |= ptr[i];
     430             :             }
     431       16146 :             *left++ = j;
     432       16146 :             v->spl_nleft++;
     433             :         }
     434             :         else
     435             :         {
     436       16332 :             if (ISALLTRUE(datum_r) || ISALLTRUE(_j))
     437             :             {
     438           0 :                 if (!ISALLTRUE(datum_r))
     439           0 :                     MemSet((void *) union_r, 0xff, siglen);
     440             :             }
     441             :             else
     442             :             {
     443       16332 :                 ptr = GETSIGN(_j);
     444    19420812 :                 LOOPBYTE(siglen)
     445    19404480 :                     union_r[i] |= ptr[i];
     446             :             }
     447       16332 :             *right++ = j;
     448       16332 :             v->spl_nright++;
     449             :         }
     450             :     }
     451             : 
     452        9016 :     *right = *left = FirstOffsetNumber;
     453        9016 :     pfree(costvector);
     454             : 
     455        9016 :     v->spl_ldatum = PointerGetDatum(datum_l);
     456        9016 :     v->spl_rdatum = PointerGetDatum(datum_r);
     457             : 
     458        9016 :     PG_RETURN_POINTER(v);
     459             : }
     460             : 
     461             : Datum
     462      174578 : g_intbig_consistent(PG_FUNCTION_ARGS)
     463             : {
     464      174578 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     465      174578 :     ArrayType  *query = PG_GETARG_ARRAYTYPE_P(1);
     466      174578 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     467             : 
     468             :     /* Oid      subtype = PG_GETARG_OID(3); */
     469      174578 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     470      174578 :     int         siglen = GET_SIGLEN();
     471             :     bool        retval;
     472             : 
     473             :     /* All cases served by this function are inexact */
     474      174578 :     *recheck = true;
     475             : 
     476      174578 :     if (ISALLTRUE(DatumGetPointer(entry->key)))
     477           0 :         PG_RETURN_BOOL(true);
     478             : 
     479      174578 :     if (strategy == BooleanSearchStrategy)
     480             :     {
     481      102532 :         retval = signconsistent((QUERYTYPE *) query,
     482      102532 :                                 GETSIGN(DatumGetPointer(entry->key)),
     483             :                                 siglen,
     484             :                                 false);
     485      102532 :         PG_FREE_IF_COPY(query, 1);
     486      102532 :         PG_RETURN_BOOL(retval);
     487             :     }
     488             : 
     489       72046 :     CHECKARRVALID(query);
     490             : 
     491       72046 :     switch (strategy)
     492             :     {
     493       15004 :         case RTOverlapStrategyNumber:
     494       15004 :             retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key),
     495             :                                      query, siglen);
     496       15004 :             break;
     497        2680 :         case RTSameStrategyNumber:
     498        2680 :             if (GIST_LEAF(entry))
     499             :             {
     500             :                 int         i,
     501        1326 :                             num = ARRNELEMS(query);
     502        1326 :                 int32      *ptr = ARRPTR(query);
     503        1326 :                 BITVECP     dq = palloc0(siglen),
     504             :                             de;
     505             : 
     506        5304 :                 while (num--)
     507             :                 {
     508        3978 :                     HASH(dq, *ptr, siglen);
     509        3978 :                     ptr++;
     510             :                 }
     511             : 
     512        1326 :                 de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key));
     513        1326 :                 retval = true;
     514        7646 :                 LOOPBYTE(siglen)
     515             :                 {
     516        7642 :                     if (de[i] != dq[i])
     517             :                     {
     518        1322 :                         retval = false;
     519        1322 :                         break;
     520             :                     }
     521             :                 }
     522             : 
     523        1326 :                 pfree(dq);
     524             :             }
     525             :             else
     526        1354 :                 retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key),
     527             :                                           query, siglen);
     528        2680 :             break;
     529       18300 :         case RTContainsStrategyNumber:
     530             :         case RTOldContainsStrategyNumber:
     531       18300 :             retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key),
     532             :                                       query, siglen);
     533       18300 :             break;
     534       36062 :         case RTContainedByStrategyNumber:
     535             :         case RTOldContainedByStrategyNumber:
     536       36062 :             if (GIST_LEAF(entry))
     537             :             {
     538             :                 int         i,
     539       27024 :                             num = ARRNELEMS(query);
     540       27024 :                 int32      *ptr = ARRPTR(query);
     541       27024 :                 BITVECP     dq = palloc0(siglen),
     542             :                             de;
     543             : 
     544      108096 :                 while (num--)
     545             :                 {
     546       81072 :                     HASH(dq, *ptr, siglen);
     547       81072 :                     ptr++;
     548             :                 }
     549             : 
     550       27024 :                 de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key));
     551       27024 :                 retval = true;
     552      172132 :                 LOOPBYTE(siglen)
     553             :                 {
     554      172092 :                     if (de[i] & ~dq[i])
     555             :                     {
     556       26984 :                         retval = false;
     557       26984 :                         break;
     558             :                     }
     559             :                 }
     560             :             }
     561             :             else
     562             :             {
     563             :                 /*
     564             :                  * Unfortunately, because empty arrays could be anywhere in
     565             :                  * the index, we must search the whole tree.
     566             :                  */
     567        9038 :                 retval = true;
     568             :             }
     569       36062 :             break;
     570           0 :         default:
     571           0 :             retval = false;
     572             :     }
     573       72046 :     PG_FREE_IF_COPY(query, 1);
     574       72046 :     PG_RETURN_BOOL(retval);
     575             : }
     576             : 
     577             : Datum
     578          18 : g_intbig_options(PG_FUNCTION_ARGS)
     579             : {
     580          18 :     local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
     581             : 
     582          18 :     init_local_reloptions(relopts, sizeof(GISTIntArrayBigOptions));
     583          18 :     add_local_int_reloption(relopts, "siglen",
     584             :                             "signature length in bytes",
     585             :                             SIGLEN_DEFAULT, 1, SIGLEN_MAX,
     586             :                             offsetof(GISTIntArrayBigOptions, siglen));
     587             : 
     588          18 :     PG_RETURN_VOID();
     589             : }

Generated by: LCOV version 1.13