LCOV - code coverage report
Current view: top level - contrib/intarray - _int_bool.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 258 276 93.5 %
Date: 2019-11-21 13:06:38 Functions: 22 24 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * contrib/intarray/_int_bool.c
       3             :  */
       4             : #include "postgres.h"
       5             : 
       6             : #include "_int.h"
       7             : #include "miscadmin.h"
       8             : #include "utils/builtins.h"
       9             : 
      10           4 : PG_FUNCTION_INFO_V1(bqarr_in);
      11           4 : PG_FUNCTION_INFO_V1(bqarr_out);
      12           4 : PG_FUNCTION_INFO_V1(boolop);
      13           2 : PG_FUNCTION_INFO_V1(rboolop);
      14           2 : PG_FUNCTION_INFO_V1(querytree);
      15             : 
      16             : 
      17             : /* parser's states */
      18             : #define WAITOPERAND 1
      19             : #define WAITENDOPERAND  2
      20             : #define WAITOPERATOR    3
      21             : 
      22             : /*
      23             :  * node of query tree, also used
      24             :  * for storing polish notation in parser
      25             :  */
      26             : typedef struct NODE
      27             : {
      28             :     int32       type;
      29             :     int32       val;
      30             :     struct NODE *next;
      31             : } NODE;
      32             : 
      33             : typedef struct
      34             : {
      35             :     char       *buf;
      36             :     int32       state;
      37             :     int32       count;
      38             :     /* reverse polish notation in list (for temporary usage) */
      39             :     NODE       *str;
      40             :     /* number in str */
      41             :     int32       num;
      42             : } WORKSTATE;
      43             : 
      44             : /*
      45             :  * get token from query string
      46             :  */
      47             : static int32
      48         814 : gettoken(WORKSTATE *state, int32 *val)
      49             : {
      50             :     char        nnn[16];
      51             :     int         innn;
      52             : 
      53         814 :     *val = 0;                   /* default result */
      54             : 
      55         814 :     innn = 0;
      56             :     while (1)
      57             :     {
      58        1734 :         if (innn >= sizeof(nnn))
      59           0 :             return ERR;         /* buffer overrun => syntax error */
      60        1274 :         switch (state->state)
      61             :         {
      62             :             case WAITOPERAND:
      63         470 :                 innn = 0;
      64         638 :                 if ((*(state->buf) >= '0' && *(state->buf) <= '9') ||
      65         168 :                     *(state->buf) == '-')
      66             :                 {
      67         302 :                     state->state = WAITENDOPERAND;
      68         302 :                     nnn[innn++] = *(state->buf);
      69             :                 }
      70         168 :                 else if (*(state->buf) == '!')
      71             :                 {
      72          78 :                     (state->buf)++;
      73          78 :                     *val = (int32) '!';
      74          78 :                     return OPR;
      75             :                 }
      76          90 :                 else if (*(state->buf) == '(')
      77             :                 {
      78          66 :                     state->count++;
      79          66 :                     (state->buf)++;
      80          66 :                     return OPEN;
      81             :                 }
      82          24 :                 else if (*(state->buf) != ' ')
      83           0 :                     return ERR;
      84         326 :                 break;
      85             :             case WAITENDOPERAND:
      86         414 :                 if (*(state->buf) >= '0' && *(state->buf) <= '9')
      87             :                 {
      88         112 :                     nnn[innn++] = *(state->buf);
      89             :                 }
      90             :                 else
      91             :                 {
      92             :                     long        lval;
      93             : 
      94         302 :                     nnn[innn] = '\0';
      95         302 :                     errno = 0;
      96         302 :                     lval = strtol(nnn, NULL, 0);
      97         302 :                     *val = (int32) lval;
      98         302 :                     if (errno != 0 || (long) *val != lval)
      99           0 :                         return ERR;
     100         302 :                     state->state = WAITOPERATOR;
     101         414 :                     return (state->count && *(state->buf) == '\0')
     102         302 :                         ? ERR : VAL;
     103             :                 }
     104         112 :                 break;
     105             :             case WAITOPERATOR:
     106         390 :                 if (*(state->buf) == '&' || *(state->buf) == '|')
     107             :                 {
     108         180 :                     state->state = WAITOPERAND;
     109         180 :                     *val = (int32) *(state->buf);
     110         180 :                     (state->buf)++;
     111         180 :                     return OPR;
     112             :                 }
     113         210 :                 else if (*(state->buf) == ')')
     114             :                 {
     115          66 :                     (state->buf)++;
     116          66 :                     state->count--;
     117          66 :                     return (state->count < 0) ? ERR : CLOSE;
     118             :                 }
     119         144 :                 else if (*(state->buf) == '\0')
     120         122 :                     return (state->count) ? ERR : END;
     121          22 :                 else if (*(state->buf) != ' ')
     122           0 :                     return ERR;
     123          22 :                 break;
     124             :             default:
     125           0 :                 return ERR;
     126             :                 break;
     127             :         }
     128         460 :         (state->buf)++;
     129             :     }
     130             : }
     131             : 
     132             : /*
     133             :  * push new one in polish notation reverse view
     134             :  */
     135             : static void
     136         560 : pushquery(WORKSTATE *state, int32 type, int32 val)
     137             : {
     138         560 :     NODE       *tmp = (NODE *) palloc(sizeof(NODE));
     139             : 
     140         560 :     tmp->type = type;
     141         560 :     tmp->val = val;
     142         560 :     tmp->next = state->str;
     143         560 :     state->str = tmp;
     144         560 :     state->num++;
     145         560 : }
     146             : 
     147             : #define STACKDEPTH  16
     148             : 
     149             : /*
     150             :  * make polish notation of query
     151             :  */
     152             : static int32
     153         188 : makepol(WORKSTATE *state)
     154             : {
     155             :     int32       val,
     156             :                 type;
     157             :     int32       stack[STACKDEPTH];
     158         188 :     int32       lenstack = 0;
     159             : 
     160             :     /* since this function recurses, it could be driven to stack overflow */
     161         188 :     check_stack_depth();
     162             : 
     163         188 :     while ((type = gettoken(state, &val)) != END)
     164             :     {
     165         692 :         switch (type)
     166             :         {
     167             :             case VAL:
     168         302 :                 pushquery(state, type, val);
     169         882 :                 while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
     170         132 :                                     stack[lenstack - 1] == (int32) '!'))
     171             :                 {
     172         146 :                     lenstack--;
     173         146 :                     pushquery(state, OPR, stack[lenstack]);
     174             :                 }
     175         302 :                 break;
     176             :             case OPR:
     177         258 :                 if (lenstack && val == (int32) '|')
     178           6 :                     pushquery(state, OPR, val);
     179             :                 else
     180             :                 {
     181         252 :                     if (lenstack == STACKDEPTH)
     182           0 :                         ereport(ERROR,
     183             :                                 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
     184             :                                  errmsg("statement too complex")));
     185         252 :                     stack[lenstack] = val;
     186         252 :                     lenstack++;
     187             :                 }
     188         258 :                 break;
     189             :             case OPEN:
     190          66 :                 if (makepol(state) == ERR)
     191           0 :                     return ERR;
     192         198 :                 while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
     193          32 :                                     stack[lenstack - 1] == (int32) '!'))
     194             :                 {
     195          34 :                     lenstack--;
     196          34 :                     pushquery(state, OPR, stack[lenstack]);
     197             :                 }
     198          66 :                 break;
     199             :             case CLOSE:
     200         156 :                 while (lenstack)
     201             :                 {
     202          24 :                     lenstack--;
     203          24 :                     pushquery(state, OPR, stack[lenstack]);
     204             :                 };
     205          66 :                 return END;
     206             :                 break;
     207             :             case ERR:
     208             :             default:
     209           0 :                 ereport(ERROR,
     210             :                         (errcode(ERRCODE_SYNTAX_ERROR),
     211             :                          errmsg("syntax error")));
     212             :                 return ERR;
     213             : 
     214             :         }
     215             :     }
     216             : 
     217         292 :     while (lenstack)
     218             :     {
     219          48 :         lenstack--;
     220          48 :         pushquery(state, OPR, stack[lenstack]);
     221             :     };
     222         122 :     return END;
     223             : }
     224             : 
     225             : typedef struct
     226             : {
     227             :     int32      *arrb;
     228             :     int32      *arre;
     229             : } CHKVAL;
     230             : 
     231             : /*
     232             :  * is there value 'val' in (sorted) array or not ?
     233             :  */
     234             : static bool
     235      290950 : checkcondition_arr(void *checkval, ITEM *item)
     236             : {
     237      290950 :     int32      *StopLow = ((CHKVAL *) checkval)->arrb;
     238      290950 :     int32      *StopHigh = ((CHKVAL *) checkval)->arre;
     239             :     int32      *StopMiddle;
     240             : 
     241             :     /* Loop invariant: StopLow <= val < StopHigh */
     242             : 
     243     1294534 :     while (StopLow < StopHigh)
     244             :     {
     245      723948 :         StopMiddle = StopLow + (StopHigh - StopLow) / 2;
     246      723948 :         if (*StopMiddle == item->val)
     247       11314 :             return true;
     248      712634 :         else if (*StopMiddle < item->val)
     249      170304 :             StopLow = StopMiddle + 1;
     250             :         else
     251      542330 :             StopHigh = StopMiddle;
     252             :     }
     253      279636 :     return false;
     254             : }
     255             : 
     256             : static bool
     257       48160 : checkcondition_bit(void *checkval, ITEM *item)
     258             : {
     259       48160 :     return GETBIT(checkval, HASHVAL(item->val));
     260             : }
     261             : 
     262             : /*
     263             :  * evaluate boolean expression, using chkcond() to test the primitive cases
     264             :  */
     265             : static bool
     266      893326 : execute(ITEM *curitem, void *checkval, bool calcnot,
     267             :         bool (*chkcond) (void *checkval, ITEM *item))
     268             : {
     269             :     /* since this function recurses, it could be driven to stack overflow */
     270      893326 :     check_stack_depth();
     271             : 
     272      893326 :     if (curitem->type == VAL)
     273      397090 :         return (*chkcond) (checkval, curitem);
     274      496236 :     else if (curitem->val == (int32) '!')
     275             :     {
     276             :         return calcnot ?
     277      158598 :             ((execute(curitem - 1, checkval, calcnot, chkcond)) ? false : true)
     278      359352 :             : true;
     279             :     }
     280      295482 :     else if (curitem->val == (int32) '&')
     281             :     {
     282      164734 :         if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
     283       72112 :             return execute(curitem - 1, checkval, calcnot, chkcond);
     284             :         else
     285       92622 :             return false;
     286             :     }
     287             :     else
     288             :     {                           /* |-operator */
     289      130748 :         if (execute(curitem + curitem->left, checkval, calcnot, chkcond))
     290        5396 :             return true;
     291             :         else
     292      125352 :             return execute(curitem - 1, checkval, calcnot, chkcond);
     293             :     }
     294             : }
     295             : 
     296             : /*
     297             :  * signconsistent & execconsistent called by *_consistent
     298             :  */
     299             : bool
     300       47674 : signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot)
     301             : {
     302       47674 :     return execute(GETQUERY(query) + query->size - 1,
     303             :                    (void *) sign, calcnot,
     304             :                    checkcondition_bit);
     305             : }
     306             : 
     307             : /* Array must be sorted! */
     308             : bool
     309       55320 : execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot)
     310             : {
     311             :     CHKVAL      chkval;
     312             : 
     313       55320 :     CHECKARRVALID(array);
     314       55320 :     chkval.arrb = ARRPTR(array);
     315       55320 :     chkval.arre = chkval.arrb + ARRNELEMS(array);
     316       55320 :     return execute(GETQUERY(query) + query->size - 1,
     317             :                    (void *) &chkval, calcnot,
     318             :                    checkcondition_arr);
     319             : }
     320             : 
     321             : typedef struct
     322             : {
     323             :     ITEM       *first;
     324             :     bool       *mapped_check;
     325             : } GinChkVal;
     326             : 
     327             : static bool
     328       57980 : checkcondition_gin(void *checkval, ITEM *item)
     329             : {
     330       57980 :     GinChkVal  *gcv = (GinChkVal *) checkval;
     331             : 
     332       57980 :     return gcv->mapped_check[item - gcv->first];
     333             : }
     334             : 
     335             : bool
     336       29802 : gin_bool_consistent(QUERYTYPE *query, bool *check)
     337             : {
     338             :     GinChkVal   gcv;
     339       29802 :     ITEM       *items = GETQUERY(query);
     340             :     int         i,
     341       29802 :                 j = 0;
     342             : 
     343       29802 :     if (query->size <= 0)
     344           0 :         return false;
     345             : 
     346             :     /*
     347             :      * Set up data for checkcondition_gin.  This must agree with the query
     348             :      * extraction code in ginint4_queryextract.
     349             :      */
     350       29802 :     gcv.first = items;
     351       29802 :     gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size);
     352      164420 :     for (i = 0; i < query->size; i++)
     353             :     {
     354      134618 :         if (items[i].type == VAL)
     355       61928 :             gcv.mapped_check[i] = check[j++];
     356             :     }
     357             : 
     358       29802 :     return execute(GETQUERY(query) + query->size - 1,
     359             :                    (void *) &gcv, true,
     360             :                    checkcondition_gin);
     361             : }
     362             : 
     363             : static bool
     364          72 : contains_required_value(ITEM *curitem)
     365             : {
     366             :     /* since this function recurses, it could be driven to stack overflow */
     367          72 :     check_stack_depth();
     368             : 
     369          72 :     if (curitem->type == VAL)
     370          28 :         return true;
     371          44 :     else if (curitem->val == (int32) '!')
     372             :     {
     373             :         /*
     374             :          * Assume anything under a NOT is non-required.  For some cases with
     375             :          * nested NOTs, we could prove there's a required value, but it seems
     376             :          * unlikely to be worth the trouble.
     377             :          */
     378          12 :         return false;
     379             :     }
     380          32 :     else if (curitem->val == (int32) '&')
     381             :     {
     382             :         /* If either side has a required value, we're good */
     383          20 :         if (contains_required_value(curitem + curitem->left))
     384          16 :             return true;
     385             :         else
     386           4 :             return contains_required_value(curitem - 1);
     387             :     }
     388             :     else
     389             :     {                           /* |-operator */
     390             :         /* Both sides must have required values */
     391          12 :         if (contains_required_value(curitem + curitem->left))
     392          12 :             return contains_required_value(curitem - 1);
     393             :         else
     394           0 :             return false;
     395             :     }
     396             : }
     397             : 
     398             : bool
     399          24 : query_has_required_values(QUERYTYPE *query)
     400             : {
     401          24 :     if (query->size <= 0)
     402           0 :         return false;
     403          24 :     return contains_required_value(GETQUERY(query) + query->size - 1);
     404             : }
     405             : 
     406             : /*
     407             :  * boolean operations
     408             :  */
     409             : Datum
     410           0 : rboolop(PG_FUNCTION_ARGS)
     411             : {
     412             :     /* just reverse the operands */
     413           0 :     return DirectFunctionCall2(boolop,
     414             :                                PG_GETARG_DATUM(1),
     415             :                                PG_GETARG_DATUM(0));
     416             : }
     417             : 
     418             : Datum
     419      108986 : boolop(PG_FUNCTION_ARGS)
     420             : {
     421      108986 :     ArrayType  *val = PG_GETARG_ARRAYTYPE_P_COPY(0);
     422      108986 :     QUERYTYPE  *query = PG_GETARG_QUERYTYPE_P(1);
     423             :     CHKVAL      chkval;
     424             :     bool        result;
     425             : 
     426      108986 :     CHECKARRVALID(val);
     427      108986 :     PREPAREARR(val);
     428      108986 :     chkval.arrb = ARRPTR(val);
     429      108986 :     chkval.arre = chkval.arrb + ARRNELEMS(val);
     430      108986 :     result = execute(GETQUERY(query) + query->size - 1,
     431             :                      &chkval, true,
     432             :                      checkcondition_arr);
     433      108986 :     pfree(val);
     434             : 
     435      108986 :     PG_FREE_IF_COPY(query, 1);
     436      108986 :     PG_RETURN_BOOL(result);
     437             : }
     438             : 
     439             : static void
     440         560 : findoprnd(ITEM *ptr, int32 *pos)
     441             : {
     442             :     /* since this function recurses, it could be driven to stack overflow. */
     443         560 :     check_stack_depth();
     444             : 
     445             : #ifdef BS_DEBUG
     446             :     elog(DEBUG3, (ptr[*pos].type == OPR) ?
     447             :          "%d  %c" : "%d  %d", *pos, ptr[*pos].val);
     448             : #endif
     449         560 :     if (ptr[*pos].type == VAL)
     450             :     {
     451         302 :         ptr[*pos].left = 0;
     452         302 :         (*pos)--;
     453             :     }
     454         258 :     else if (ptr[*pos].val == (int32) '!')
     455             :     {
     456          78 :         ptr[*pos].left = -1;
     457          78 :         (*pos)--;
     458          78 :         findoprnd(ptr, pos);
     459             :     }
     460             :     else
     461             :     {
     462         180 :         ITEM       *curitem = &ptr[*pos];
     463         180 :         int32       tmp = *pos;
     464             : 
     465         180 :         (*pos)--;
     466         180 :         findoprnd(ptr, pos);
     467         180 :         curitem->left = *pos - tmp;
     468         180 :         findoprnd(ptr, pos);
     469             :     }
     470         560 : }
     471             : 
     472             : 
     473             : /*
     474             :  * input
     475             :  */
     476             : Datum
     477         122 : bqarr_in(PG_FUNCTION_ARGS)
     478             : {
     479         122 :     char       *buf = (char *) PG_GETARG_POINTER(0);
     480             :     WORKSTATE   state;
     481             :     int32       i;
     482             :     QUERYTYPE  *query;
     483             :     int32       commonlen;
     484             :     ITEM       *ptr;
     485             :     NODE       *tmp;
     486         122 :     int32       pos = 0;
     487             : 
     488             : #ifdef BS_DEBUG
     489             :     StringInfoData pbuf;
     490             : #endif
     491             : 
     492         122 :     state.buf = buf;
     493         122 :     state.state = WAITOPERAND;
     494         122 :     state.count = 0;
     495         122 :     state.num = 0;
     496         122 :     state.str = NULL;
     497             : 
     498             :     /* make polish notation (postfix, but in reverse order) */
     499         122 :     makepol(&state);
     500         122 :     if (!state.num)
     501           0 :         ereport(ERROR,
     502             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     503             :                  errmsg("empty query")));
     504             : 
     505         122 :     if (state.num > QUERYTYPEMAXITEMS)
     506           0 :         ereport(ERROR,
     507             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     508             :                  errmsg("number of query items (%d) exceeds the maximum allowed (%d)",
     509             :                         state.num, (int) QUERYTYPEMAXITEMS)));
     510         122 :     commonlen = COMPUTESIZE(state.num);
     511             : 
     512         122 :     query = (QUERYTYPE *) palloc(commonlen);
     513         122 :     SET_VARSIZE(query, commonlen);
     514         122 :     query->size = state.num;
     515         122 :     ptr = GETQUERY(query);
     516             : 
     517         682 :     for (i = state.num - 1; i >= 0; i--)
     518             :     {
     519         560 :         ptr[i].type = state.str->type;
     520         560 :         ptr[i].val = state.str->val;
     521         560 :         tmp = state.str->next;
     522         560 :         pfree(state.str);
     523         560 :         state.str = tmp;
     524             :     }
     525             : 
     526         122 :     pos = query->size - 1;
     527         122 :     findoprnd(ptr, &pos);
     528             : #ifdef BS_DEBUG
     529             :     initStringInfo(&pbuf);
     530             :     for (i = 0; i < query->size; i++)
     531             :     {
     532             :         if (ptr[i].type == OPR)
     533             :             appendStringInfo(&pbuf, "%c(%d) ", ptr[i].val, ptr[i].left);
     534             :         else
     535             :             appendStringInfo(&pbuf, "%d ", ptr[i].val);
     536             :     }
     537             :     elog(DEBUG3, "POR: %s", pbuf.data);
     538             :     pfree(pbuf.data);
     539             : #endif
     540             : 
     541         122 :     PG_RETURN_POINTER(query);
     542             : }
     543             : 
     544             : 
     545             : /*
     546             :  * out function
     547             :  */
     548             : typedef struct
     549             : {
     550             :     ITEM       *curpol;
     551             :     char       *buf;
     552             :     char       *cur;
     553             :     int32       buflen;
     554             : } INFIX;
     555             : 
     556             : #define RESIZEBUF(inf,addsize) while( ( (inf)->cur - (inf)->buf ) + (addsize) + 1 >= (inf)->buflen ) { \
     557             :     int32 len = inf->cur - inf->buf; \
     558             :     inf->buflen *= 2; \
     559             :     inf->buf = (char*) repalloc( (void*)inf->buf, inf->buflen ); \
     560             :     inf->cur = inf->buf + len; \
     561             : }
     562             : 
     563             : static void
     564         360 : infix(INFIX *in, bool first)
     565             : {
     566             :     /* since this function recurses, it could be driven to stack overflow. */
     567         360 :     check_stack_depth();
     568             : 
     569         360 :     if (in->curpol->type == VAL)
     570             :     {
     571         190 :         RESIZEBUF(in, 11);
     572         190 :         sprintf(in->cur, "%d", in->curpol->val);
     573         190 :         in->cur = strchr(in->cur, '\0');
     574         190 :         in->curpol--;
     575             :     }
     576         170 :     else if (in->curpol->val == (int32) '!')
     577             :     {
     578          54 :         bool        isopr = false;
     579             : 
     580          54 :         RESIZEBUF(in, 1);
     581          54 :         *(in->cur) = '!';
     582          54 :         in->cur++;
     583          54 :         *(in->cur) = '\0';
     584          54 :         in->curpol--;
     585          54 :         if (in->curpol->type == OPR)
     586             :         {
     587          12 :             isopr = true;
     588          12 :             RESIZEBUF(in, 2);
     589          12 :             sprintf(in->cur, "( ");
     590          12 :             in->cur = strchr(in->cur, '\0');
     591             :         }
     592          54 :         infix(in, isopr);
     593          54 :         if (isopr)
     594             :         {
     595          12 :             RESIZEBUF(in, 2);
     596          12 :             sprintf(in->cur, " )");
     597          12 :             in->cur = strchr(in->cur, '\0');
     598             :         }
     599             :     }
     600             :     else
     601             :     {
     602         116 :         int32       op = in->curpol->val;
     603             :         INFIX       nrm;
     604             : 
     605         116 :         in->curpol--;
     606         116 :         if (op == (int32) '|' && !first)
     607             :         {
     608          20 :             RESIZEBUF(in, 2);
     609          20 :             sprintf(in->cur, "( ");
     610          20 :             in->cur = strchr(in->cur, '\0');
     611             :         }
     612             : 
     613         116 :         nrm.curpol = in->curpol;
     614         116 :         nrm.buflen = 16;
     615         116 :         nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
     616             : 
     617             :         /* get right operand */
     618         116 :         infix(&nrm, false);
     619             : 
     620             :         /* get & print left operand */
     621         116 :         in->curpol = nrm.curpol;
     622         116 :         infix(in, false);
     623             : 
     624             :         /* print operator & right operand */
     625         116 :         RESIZEBUF(in, 3 + (nrm.cur - nrm.buf));
     626         116 :         sprintf(in->cur, " %c %s", op, nrm.buf);
     627         116 :         in->cur = strchr(in->cur, '\0');
     628         116 :         pfree(nrm.buf);
     629             : 
     630         116 :         if (op == (int32) '|' && !first)
     631             :         {
     632          20 :             RESIZEBUF(in, 2);
     633          20 :             sprintf(in->cur, " )");
     634          20 :             in->cur = strchr(in->cur, '\0');
     635             :         }
     636             :     }
     637         360 : }
     638             : 
     639             : 
     640             : Datum
     641          74 : bqarr_out(PG_FUNCTION_ARGS)
     642             : {
     643          74 :     QUERYTYPE  *query = PG_GETARG_QUERYTYPE_P(0);
     644             :     INFIX       nrm;
     645             : 
     646          74 :     if (query->size == 0)
     647           0 :         ereport(ERROR,
     648             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     649             :                  errmsg("empty query")));
     650             : 
     651          74 :     nrm.curpol = GETQUERY(query) + query->size - 1;
     652          74 :     nrm.buflen = 32;
     653          74 :     nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
     654          74 :     *(nrm.cur) = '\0';
     655          74 :     infix(&nrm, true);
     656             : 
     657          74 :     PG_FREE_IF_COPY(query, 0);
     658          74 :     PG_RETURN_POINTER(nrm.buf);
     659             : }
     660             : 
     661             : 
     662             : /* Useless old "debugging" function for a fundamentally wrong algorithm */
     663             : Datum
     664           0 : querytree(PG_FUNCTION_ARGS)
     665             : {
     666           0 :     elog(ERROR, "querytree is no longer implemented");
     667             :     PG_RETURN_NULL();
     668             : }

Generated by: LCOV version 1.13