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

Generated by: LCOV version 1.13