LCOV - code coverage report
Current view: top level - contrib/intarray - _intbig_gist.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 241 279 86.4 %
Date: 2020-02-27 20:07:29 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        8958 : _intbig_overlap(GISTTYPE *a, ArrayType *b)
      49             : {
      50        8958 :     int         num = ARRNELEMS(b);
      51        8958 :     int32      *ptr = ARRPTR(b);
      52             : 
      53        8958 :     CHECKARRVALID(b);
      54             : 
      55       24992 :     while (num--)
      56             :     {
      57       17232 :         if (GETBIT(GETSIGN(a), HASHVAL(*ptr)))
      58        1198 :             return true;
      59       16034 :         ptr++;
      60             :     }
      61             : 
      62        7760 :     return false;
      63             : }
      64             : 
      65             : static bool
      66       12250 : _intbig_contains(GISTTYPE *a, ArrayType *b)
      67             : {
      68       12250 :     int         num = ARRNELEMS(b);
      69       12250 :     int32      *ptr = ARRPTR(b);
      70             : 
      71       12250 :     CHECKARRVALID(b);
      72             : 
      73       15092 :     while (num--)
      74             :     {
      75       14416 :         if (!GETBIT(GETSIGN(a), HASHVAL(*ptr)))
      76       11574 :             return false;
      77        2842 :         ptr++;
      78             :     }
      79             : 
      80         676 :     return true;
      81             : }
      82             : 
      83             : Datum
      84       25736 : g_intbig_same(PG_FUNCTION_ARGS)
      85             : {
      86       25736 :     GISTTYPE   *a = (GISTTYPE *) PG_GETARG_POINTER(0);
      87       25736 :     GISTTYPE   *b = (GISTTYPE *) PG_GETARG_POINTER(1);
      88       25736 :     bool       *result = (bool *) PG_GETARG_POINTER(2);
      89             : 
      90       25736 :     if (ISALLTRUE(a) && ISALLTRUE(b))
      91           0 :         *result = true;
      92       25736 :     else if (ISALLTRUE(a))
      93           0 :         *result = false;
      94       25736 :     else if (ISALLTRUE(b))
      95           0 :         *result = false;
      96             :     else
      97             :     {
      98             :         int32       i;
      99       25736 :         BITVECP     sa = GETSIGN(a),
     100       25736 :                     sb = GETSIGN(b);
     101             : 
     102       25736 :         *result = true;
     103     3353484 :         LOOPBYTE
     104             :         {
     105     3340746 :             if (sa[i] != sb[i])
     106             :             {
     107       12998 :                 *result = false;
     108       12998 :                 break;
     109             :             }
     110             :         }
     111             :     }
     112       25736 :     PG_RETURN_POINTER(result);
     113             : }
     114             : 
     115             : Datum
     116       27766 : g_intbig_compress(PG_FUNCTION_ARGS)
     117             : {
     118       27766 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     119             : 
     120       27766 :     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       67806 :         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       14254 :     else if (!ISALLTRUE(DatumGetPointer(entry->key)))
     158             :     {
     159             :         GISTENTRY  *retval;
     160             :         int         i;
     161       14254 :         BITVECP     sign = GETSIGN(DatumGetPointer(entry->key));
     162             :         GISTTYPE   *res;
     163             : 
     164       19260 :         LOOPBYTE
     165             :         {
     166       19260 :             if ((sign[i] & 0xff) != 0xff)
     167       14254 :                 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      620094 : hemdistsign(BITVECP a, BITVECP b)
     194             : {
     195             :     int         i,
     196             :                 diff,
     197      620094 :                 dist = 0;
     198             : 
     199   156883782 :     LOOPBYTE
     200             :     {
     201   156263688 :         diff = (unsigned char) (a[i] ^ b[i]);
     202             :         /* Using the popcount functions here isn't likely to win */
     203   156263688 :         dist += pg_number_of_ones[diff];
     204             :     }
     205      620094 :     return dist;
     206             : }
     207             : 
     208             : static int
     209      620094 : hemdist(GISTTYPE *a, GISTTYPE *b)
     210             : {
     211      620094 :     if (ISALLTRUE(a))
     212             :     {
     213           0 :         if (ISALLTRUE(b))
     214           0 :             return 0;
     215             :         else
     216           0 :             return SIGLENBIT - sizebitvec(GETSIGN(b));
     217             :     }
     218      620094 :     else if (ISALLTRUE(b))
     219           0 :         return SIGLENBIT - sizebitvec(GETSIGN(a));
     220             : 
     221      620094 :     return hemdistsign(GETSIGN(a), GETSIGN(b));
     222             : }
     223             : 
     224             : Datum
     225      534264 : g_intbig_decompress(PG_FUNCTION_ARGS)
     226             : {
     227      534264 :     PG_RETURN_DATUM(PG_GETARG_DATUM(0));
     228             : }
     229             : 
     230             : static int32
     231       52016 : unionkey(BITVECP sbase, GISTTYPE *add)
     232             : {
     233             :     int32       i;
     234       52016 :     BITVECP     sadd = GETSIGN(add);
     235             : 
     236       52016 :     if (ISALLTRUE(add))
     237           0 :         return 1;
     238    13160048 :     LOOPBYTE
     239    13108032 :         sbase[i] |= sadd[i];
     240       52016 :     return 0;
     241             : }
     242             : 
     243             : Datum
     244       25858 : g_intbig_union(PG_FUNCTION_ARGS)
     245             : {
     246       25858 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     247       25858 :     int        *size = (int *) PG_GETARG_POINTER(1);
     248             :     BITVEC      base;
     249             :     int32       i,
     250             :                 len;
     251       25858 :     int32       flag = 0;
     252             :     GISTTYPE   *result;
     253             : 
     254       25858 :     MemSet((void *) base, 0, sizeof(BITVEC));
     255       77874 :     for (i = 0; i < entryvec->n; i++)
     256             :     {
     257       52016 :         if (unionkey(base, GETENTRY(entryvec, i)))
     258             :         {
     259           0 :             flag = ALLISTRUE;
     260           0 :             break;
     261             :         }
     262             :     }
     263             : 
     264       25858 :     len = CALCGTSIZE(flag);
     265       25858 :     result = (GISTTYPE *) palloc(len);
     266       25858 :     SET_VARSIZE(result, len);
     267       25858 :     result->flag = flag;
     268       25858 :     if (!ISALLTRUE(result))
     269       25858 :         memcpy((void *) GETSIGN(result), (void *) base, sizeof(BITVEC));
     270       25858 :     *size = len;
     271             : 
     272       25858 :     PG_RETURN_POINTER(result);
     273             : }
     274             : 
     275             : Datum
     276      353076 : g_intbig_penalty(PG_FUNCTION_ARGS)
     277             : {
     278      353076 :     GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
     279      353076 :     GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
     280      353076 :     float      *penalty = (float *) PG_GETARG_POINTER(2);
     281      353076 :     GISTTYPE   *origval = (GISTTYPE *) DatumGetPointer(origentry->key);
     282      353076 :     GISTTYPE   *newval = (GISTTYPE *) DatumGetPointer(newentry->key);
     283             : 
     284      353076 :     *penalty = hemdist(origval, newval);
     285      353076 :     PG_RETURN_POINTER(penalty);
     286             : }
     287             : 
     288             : 
     289             : typedef struct
     290             : {
     291             :     OffsetNumber pos;
     292             :     int32       cost;
     293             : } SPLITCOST;
     294             : 
     295             : static int
     296       33236 : comparecost(const void *a, const void *b)
     297             : {
     298       33236 :     return ((const SPLITCOST *) a)->cost - ((const SPLITCOST *) b)->cost;
     299             : }
     300             : 
     301             : 
     302             : Datum
     303         622 : g_intbig_picksplit(PG_FUNCTION_ARGS)
     304             : {
     305         622 :     GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
     306         622 :     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         622 :                 waste = -1;
     317             :     int32       nbytes;
     318         622 :     OffsetNumber seed_1 = 0,
     319         622 :                 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         622 :     maxoff = entryvec->n - 2;
     330         622 :     nbytes = (maxoff + 2) * sizeof(OffsetNumber);
     331         622 :     v->spl_left = (OffsetNumber *) palloc(nbytes);
     332         622 :     v->spl_right = (OffsetNumber *) palloc(nbytes);
     333             : 
     334       16178 :     for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
     335             :     {
     336       15556 :         _k = GETENTRY(entryvec, k);
     337      217862 :         for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
     338             :         {
     339      202306 :             size_waste = hemdist(_k, GETENTRY(entryvec, j));
     340      202306 :             if (size_waste > waste)
     341             :             {
     342        3450 :                 waste = size_waste;
     343        3450 :                 seed_1 = k;
     344        3450 :                 seed_2 = j;
     345             :             }
     346             :         }
     347             :     }
     348             : 
     349         622 :     left = v->spl_left;
     350         622 :     v->spl_nleft = 0;
     351         622 :     right = v->spl_right;
     352         622 :     v->spl_nright = 0;
     353             : 
     354         622 :     if (seed_1 == 0 || seed_2 == 0)
     355             :     {
     356           0 :         seed_1 = 1;
     357           0 :         seed_2 = 2;
     358             :     }
     359             : 
     360             :     /* form initial .. */
     361         622 :     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         622 :         datum_l = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN);
     370         622 :         SET_VARSIZE(datum_l, GTHDRSIZE + SIGLEN);
     371         622 :         datum_l->flag = 0;
     372         622 :         memcpy((void *) GETSIGN(datum_l), (void *) GETSIGN(GETENTRY(entryvec, seed_1)), sizeof(BITVEC));
     373             :     }
     374         622 :     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         622 :         datum_r = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN);
     383         622 :         SET_VARSIZE(datum_r, GTHDRSIZE + SIGLEN);
     384         622 :         datum_r->flag = 0;
     385         622 :         memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC));
     386             :     }
     387             : 
     388         622 :     maxoff = OffsetNumberNext(maxoff);
     389             :     /* sort before ... */
     390         622 :     costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
     391       17422 :     for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
     392             :     {
     393       16800 :         costvector[j - 1].pos = j;
     394       16800 :         _j = GETENTRY(entryvec, j);
     395       16800 :         size_alpha = hemdist(datum_l, _j);
     396       16800 :         size_beta = hemdist(datum_r, _j);
     397       16800 :         costvector[j - 1].cost = Abs(size_alpha - size_beta);
     398             :     }
     399         622 :     qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
     400             : 
     401         622 :     union_l = GETSIGN(datum_l);
     402         622 :     union_r = GETSIGN(datum_r);
     403             : 
     404       17422 :     for (k = 0; k < maxoff; k++)
     405             :     {
     406       16800 :         j = costvector[k].pos;
     407       16800 :         if (j == seed_1)
     408             :         {
     409         622 :             *left++ = j;
     410         622 :             v->spl_nleft++;
     411         622 :             continue;
     412             :         }
     413       16178 :         else if (j == seed_2)
     414             :         {
     415         622 :             *right++ = j;
     416         622 :             v->spl_nright++;
     417         622 :             continue;
     418             :         }
     419       15556 :         _j = GETENTRY(entryvec, j);
     420       15556 :         size_alpha = hemdist(datum_l, _j);
     421       15556 :         size_beta = hemdist(datum_r, _j);
     422             : 
     423       15556 :         if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.00001))
     424             :         {
     425        7842 :             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        7842 :                 ptr = GETSIGN(_j);
     433     1984026 :                 LOOPBYTE
     434     1976184 :                     union_l[i] |= ptr[i];
     435             :             }
     436        7842 :             *left++ = j;
     437        7842 :             v->spl_nleft++;
     438             :         }
     439             :         else
     440             :         {
     441        7714 :             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        7714 :                 ptr = GETSIGN(_j);
     449     1951642 :                 LOOPBYTE
     450     1943928 :                     union_r[i] |= ptr[i];
     451             :             }
     452        7714 :             *right++ = j;
     453        7714 :             v->spl_nright++;
     454             :         }
     455             :     }
     456             : 
     457         622 :     *right = *left = FirstOffsetNumber;
     458         622 :     pfree(costvector);
     459             : 
     460         622 :     v->spl_ldatum = PointerGetDatum(datum_l);
     461         622 :     v->spl_rdatum = PointerGetDatum(datum_r);
     462             : 
     463         622 :     PG_RETURN_POINTER(v);
     464             : }
     465             : 
     466             : Datum
     467       83372 : g_intbig_consistent(PG_FUNCTION_ARGS)
     468             : {
     469       83372 :     GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
     470       83372 :     ArrayType  *query = PG_GETARG_ARRAYTYPE_P(1);
     471       83372 :     StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
     472             : 
     473             :     /* Oid      subtype = PG_GETARG_OID(3); */
     474       83372 :     bool       *recheck = (bool *) PG_GETARG_POINTER(4);
     475             :     bool        retval;
     476             : 
     477             :     /* All cases served by this function are inexact */
     478       83372 :     *recheck = true;
     479             : 
     480       83372 :     if (ISALLTRUE(DatumGetPointer(entry->key)))
     481           0 :         PG_RETURN_BOOL(true);
     482             : 
     483       83372 :     if (strategy == BooleanSearchStrategy)
     484             :     {
     485       47036 :         retval = signconsistent((QUERYTYPE *) query,
     486       47036 :                                 GETSIGN(DatumGetPointer(entry->key)),
     487             :                                 false);
     488       47036 :         PG_FREE_IF_COPY(query, 1);
     489       47036 :         PG_RETURN_BOOL(retval);
     490             :     }
     491             : 
     492       36336 :     CHECKARRVALID(query);
     493             : 
     494       36336 :     switch (strategy)
     495             :     {
     496        8958 :         case RTOverlapStrategyNumber:
     497        8958 :             retval = _intbig_overlap((GISTTYPE *) DatumGetPointer(entry->key), query);
     498        8958 :             break;
     499        1616 :         case RTSameStrategyNumber:
     500        1616 :             if (GIST_LEAF(entry))
     501             :             {
     502             :                 int         i,
     503         990 :                             num = ARRNELEMS(query);
     504         990 :                 int32      *ptr = ARRPTR(query);
     505             :                 BITVEC      qp;
     506             :                 BITVECP     dq,
     507             :                             de;
     508             : 
     509         990 :                 memset(qp, 0, sizeof(BITVEC));
     510             : 
     511        3960 :                 while (num--)
     512             :                 {
     513        2970 :                     HASH(qp, *ptr);
     514        2970 :                     ptr++;
     515             :                 }
     516             : 
     517         990 :                 de = GETSIGN((GISTTYPE *) DatumGetPointer(entry->key));
     518         990 :                 dq = qp;
     519         990 :                 retval = true;
     520        2808 :                 LOOPBYTE
     521             :                 {
     522        2806 :                     if (de[i] != dq[i])
     523             :                     {
     524         988 :                         retval = false;
     525         988 :                         break;
     526             :                     }
     527             :                 }
     528             : 
     529             :             }
     530             :             else
     531         626 :                 retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query);
     532        1616 :             break;
     533       11624 :         case RTContainsStrategyNumber:
     534             :         case RTOldContainsStrategyNumber:
     535       11624 :             retval = _intbig_contains((GISTTYPE *) DatumGetPointer(entry->key), query);
     536       11624 :             break;
     537       14138 :         case RTContainedByStrategyNumber:
     538             :         case RTOldContainedByStrategyNumber:
     539       14138 :             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       54048 :                 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         626 :                 retval = true;
     575             :             }
     576       14138 :             break;
     577           0 :         default:
     578           0 :             retval = false;
     579             :     }
     580       36336 :     PG_FREE_IF_COPY(query, 1);
     581       36336 :     PG_RETURN_BOOL(retval);
     582             : }

Generated by: LCOV version 1.13