#include "postgres.h"
#include <ctype.h>
#include "common/int.h"
#include "crc32.h"
#include "libpq/pqformat.h"
#include "ltree.h"
#include "varatt.h"

Include dependency graph for ltree_io.c:

Data Structures
struct	nodeitem

Macros
#define	LTPRS_WAITNAME 0

#define	LTPRS_WAITDELIM 1

#define	UNCHAR

#define	LQPRS_WAITLEVEL 0

#define	LQPRS_WAITDELIM 1

#define	LQPRS_WAITOPEN 2

#define	LQPRS_WAITFNUM 3

#define	LQPRS_WAITSNUM 4

#define	LQPRS_WAITND 5

#define	LQPRS_WAITCLOSE 6

#define	LQPRS_WAITEND 7

#define	LQPRS_WAITVAR 8

#define	GETVAR(x) ( ((nodeitem*)LQL_FIRST(x)) )

#define	ITEMSIZE MAXALIGN(LQL_HDRSIZE+sizeof(nodeitem*))

#define	NEXTLEV(x) ( (lquery_level)( ((char)(x)) + ITEMSIZE) )

#define	UNCHAR

Functions
static bool	finish_nodeitem (nodeitem lptr, const char ptr, bool is_lquery, int pos, struct Node *escontext)

static ltree *	parse_ltree (const char buf, struct Node escontext)

static char *	deparse_ltree (const ltree *in)

	PG_FUNCTION_INFO_V1 (ltree_in)

Datum	ltree_in (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (ltree_out)

Datum	ltree_out (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (ltree_send)

Datum	ltree_send (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (ltree_recv)

Datum	ltree_recv (PG_FUNCTION_ARGS)

static lquery *	parse_lquery (const char buf, struct Node escontext)

static char *	deparse_lquery (const lquery *in)

	PG_FUNCTION_INFO_V1 (lquery_in)

Datum	lquery_in (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (lquery_out)

Datum	lquery_out (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (lquery_send)

Datum	lquery_send (PG_FUNCTION_ARGS)

	PG_FUNCTION_INFO_V1 (lquery_recv)

Datum	lquery_recv (PG_FUNCTION_ARGS)

Macro Definition Documentation

◆ GETVAR

#define GETVAR ( x ) ( *((nodeitem**)LQL_FIRST(x)) )

Definition at line 260 of file ltree_io.c.

◆ ITEMSIZE

#define ITEMSIZE MAXALIGN(LQL_HDRSIZE+sizeof(nodeitem*))

Definition at line 261 of file ltree_io.c.

◆ LQPRS_WAITCLOSE

#define LQPRS_WAITCLOSE 6

Definition at line 255 of file ltree_io.c.

◆ LQPRS_WAITDELIM

#define LQPRS_WAITDELIM 1

Definition at line 250 of file ltree_io.c.

◆ LQPRS_WAITEND

#define LQPRS_WAITEND 7

Definition at line 256 of file ltree_io.c.

◆ LQPRS_WAITFNUM

#define LQPRS_WAITFNUM 3

Definition at line 252 of file ltree_io.c.

◆ LQPRS_WAITLEVEL

#define LQPRS_WAITLEVEL 0

Definition at line 249 of file ltree_io.c.

◆ LQPRS_WAITND

#define LQPRS_WAITND 5

Definition at line 254 of file ltree_io.c.

◆ LQPRS_WAITOPEN

#define LQPRS_WAITOPEN 2

Definition at line 251 of file ltree_io.c.

◆ LQPRS_WAITSNUM

#define LQPRS_WAITSNUM 4

Definition at line 253 of file ltree_io.c.

◆ LQPRS_WAITVAR

#define LQPRS_WAITVAR 8

Definition at line 257 of file ltree_io.c.

◆ LTPRS_WAITDELIM

#define LTPRS_WAITDELIM 1

Definition at line 26 of file ltree_io.c.

◆ LTPRS_WAITNAME

#define LTPRS_WAITNAME 0

Definition at line 25 of file ltree_io.c.

◆ NEXTLEV

#define NEXTLEV ( x ) ( (lquery_level*)( ((char*)(x)) + ITEMSIZE) )

Definition at line 262 of file ltree_io.c.

◆ UNCHAR [1/2]

#define UNCHAR

Value:

                       ereturn(escontext, NULL,\
                       errcode(ERRCODE_SYNTAX_ERROR), \
                       errmsg("ltree syntax error at character %d", \
                              pos))

◆ UNCHAR [2/2]

#define UNCHAR

Value:

                       ereturn(escontext, NULL,\
                       errcode(ERRCODE_SYNTAX_ERROR), \
                       errmsg("lquery syntax error at character %d", \
                              pos))

Function Documentation

◆ deparse_lquery()

static char * deparse_lquery ( const lquery * in )

static

Definition at line 642 of file ltree_io.c.

{
    char       *buf,
               *ptr;
    int         i,
                j,
                totallen = 1;
    lquery_level *curqlevel;
    lquery_variant *curtlevel;
 
    curqlevel = LQUERY_FIRST(in);
    for (i = 0; i < in->numlevel; i++)
    {
        totallen++;
        if (curqlevel->numvar)
        {
            totallen += 1 + (curqlevel->numvar * 4) + curqlevel->totallen;
            if (curqlevel->flag & LQL_COUNT)
                totallen += 2 * 11 + 3;
        }
        else
            totallen += 2 * 11 + 4;
        curqlevel = LQL_NEXT(curqlevel);
    }
 
    ptr = buf = (char *) palloc(totallen);
    curqlevel = LQUERY_FIRST(in);
    for (i = 0; i < in->numlevel; i++)
    {
        if (i != 0)
        {
            *ptr = '.';
            ptr++;
        }
        if (curqlevel->numvar)
        {
            if (curqlevel->flag & LQL_NOT)
            {
                *ptr = '!';
                ptr++;
            }
            curtlevel = LQL_FIRST(curqlevel);
            for (j = 0; j < curqlevel->numvar; j++)
            {
                if (j != 0)
                {
                    *ptr = '|';
                    ptr++;
                }
                memcpy(ptr, curtlevel->name, curtlevel->len);
                ptr += curtlevel->len;
                if ((curtlevel->flag & LVAR_SUBLEXEME))
                {
                    *ptr = '%';
                    ptr++;
                }
                if ((curtlevel->flag & LVAR_INCASE))
                {
                    *ptr = '@';
                    ptr++;
                }
                if ((curtlevel->flag & LVAR_ANYEND))
                {
                    *ptr = '*';
                    ptr++;
                }
                curtlevel = LVAR_NEXT(curtlevel);
            }
        }
        else
        {
            *ptr = '*';
            ptr++;
        }
 
        if ((curqlevel->flag & LQL_COUNT) || curqlevel->numvar == 0)
        {
            if (curqlevel->low == curqlevel->high)
            {
                sprintf(ptr, "{%d}", curqlevel->low);
            }
            else if (curqlevel->low == 0)
            {
                if (curqlevel->high == LTREE_MAX_LEVELS)
                {
                    if (curqlevel->numvar == 0)
                    {
                        /* This is default for '*', so print nothing */
                        *ptr = '\0';
                    }
                    else
                        sprintf(ptr, "{,}");
                }
                else
                    sprintf(ptr, "{,%d}", curqlevel->high);
            }
            else if (curqlevel->high == LTREE_MAX_LEVELS)
            {
                sprintf(ptr, "{%d,}", curqlevel->low);
            }
            else
                sprintf(ptr, "{%d,%d}", curqlevel->low, curqlevel->high);
            ptr = strchr(ptr, '\0');
        }
 
        curqlevel = LQL_NEXT(curqlevel);
    }
 
    *ptr = '\0';
    return buf;
}

References buf, fb(), i, j, LQL_COUNT, LQL_FIRST, LQL_NEXT, LQL_NOT, LQUERY_FIRST, LTREE_MAX_LEVELS, LVAR_ANYEND, LVAR_INCASE, LVAR_NEXT, LVAR_SUBLEXEME, memcpy(), lquery::numlevel, palloc(), and sprintf.

Referenced by lquery_out(), and lquery_send().

◆ deparse_ltree()

static char * deparse_ltree ( const ltree * in )

static

Definition at line 145 of file ltree_io.c.

{
    char       *buf,
               *ptr;
    int         i;
    ltree_level *curlevel;
 
    ptr = buf = (char *) palloc(VARSIZE(in));
    curlevel = LTREE_FIRST(in);
    for (i = 0; i < in->numlevel; i++)
    {
        if (i != 0)
        {
            *ptr = '.';
            ptr++;
        }
        memcpy(ptr, curlevel->name, curlevel->len);
        ptr += curlevel->len;
        curlevel = LEVEL_NEXT(curlevel);
    }
 
    *ptr = '\0';
    return buf;
}

References buf, fb(), i, LEVEL_NEXT, LTREE_FIRST, memcpy(), ltree::numlevel, palloc(), and VARSIZE().

Referenced by ltree_out(), and ltree_send().

◆ finish_nodeitem()

static bool finish_nodeitem	(	nodeitem *	lptr,
		const char *	ptr,
		bool	is_lquery,
		int	pos,
		struct Node *	escontext
	)

static

Definition at line 600 of file ltree_io.c.

{
    if (is_lquery)
    {
        /*
         * Back up over any flag characters, and discount them from length and
         * position.
         */
        while (ptr > lptr->start && strchr("@*%", ptr[-1]) != NULL)
        {
            ptr--;
            lptr->wlen--;
            pos--;
        }
    }
 
    /* Now compute the byte length, which we weren't tracking before. */
    lptr->len = ptr - lptr->start;
 
    /* Complain if it's empty or too long */
    if (lptr->len == 0)
        ereturn(escontext, false,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 is_lquery ?
                 errmsg("lquery syntax error at character %d", pos) :
                 errmsg("ltree syntax error at character %d", pos),
                 errdetail("Empty labels are not allowed.")));
    if (lptr->wlen > LTREE_LABEL_MAX_CHARS)
        ereturn(escontext, false,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("label string is too long"),
                 errdetail("Label length is %d, must be at most %d, at character %d.",
                           lptr->wlen, LTREE_LABEL_MAX_CHARS, pos)));
    return true;
}

References ereturn, errcode(), errdetail(), errmsg, fb(), and LTREE_LABEL_MAX_CHARS.

Referenced by parse_lquery(), and parse_ltree().

◆ lquery_in()

Datum lquery_in ( PG_FUNCTION_ARGS )

Definition at line 759 of file ltree_io.c.

{
    char       *buf = (char *) PG_GETARG_POINTER(0);
    lquery     *res;
 
    if ((res = parse_lquery(buf, fcinfo->context)) == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_POINTER(res);
}

References buf, fb(), parse_lquery(), PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_POINTER.

◆ lquery_out()

Datum lquery_out ( PG_FUNCTION_ARGS )

Definition at line 772 of file ltree_io.c.

{
    lquery     *in = PG_GETARG_LQUERY_P(0);
 
    PG_RETURN_POINTER(deparse_lquery(in));
}

References deparse_lquery(), PG_GETARG_LQUERY_P, and PG_RETURN_POINTER.

◆ lquery_recv()

Datum lquery_recv ( PG_FUNCTION_ARGS )

Definition at line 814 of file ltree_io.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    int         version = pq_getmsgint(buf, 1);
    char       *str;
    int         nbytes;
    lquery     *res;
 
    if (version != 1)
        elog(ERROR, "unsupported lquery version number %d", version);
 
    str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
    res = parse_lquery(str, NULL);
    pfree(str);
 
    PG_RETURN_POINTER(res);
}

References buf, elog, ERROR, fb(), parse_lquery(), pfree(), PG_GETARG_POINTER, PG_RETURN_POINTER, pq_getmsgint(), pq_getmsgtext(), and str.

◆ lquery_send()

Datum lquery_send ( PG_FUNCTION_ARGS )

Definition at line 789 of file ltree_io.c.

{
    lquery     *in = PG_GETARG_LQUERY_P(0);
    StringInfoData buf;
    int         version = 1;
    char       *res = deparse_lquery(in);
 
    pq_begintypsend(&buf);
    pq_sendint8(&buf, version);
    pq_sendtext(&buf, res, strlen(res));
    pfree(res);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, deparse_lquery(), fb(), pfree(), PG_GETARG_LQUERY_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), and pq_sendtext().

◆ ltree_in()

Datum ltree_in ( PG_FUNCTION_ARGS )

Definition at line 175 of file ltree_io.c.

{
    char       *buf = (char *) PG_GETARG_POINTER(0);
    ltree      *res;
 
    if ((res = parse_ltree(buf, fcinfo->context)) == NULL)
        PG_RETURN_NULL();
 
    PG_RETURN_POINTER(res);
}

References buf, fb(), parse_ltree(), PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_POINTER.

Referenced by ltree_addtext(), ltree_textadd(), and text2ltree().

◆ ltree_out()

Datum ltree_out ( PG_FUNCTION_ARGS )

Definition at line 188 of file ltree_io.c.

{
    ltree      *in = PG_GETARG_LTREE_P(0);
 
    PG_RETURN_POINTER(deparse_ltree(in));
}

References deparse_ltree(), PG_GETARG_LTREE_P, and PG_RETURN_POINTER.

◆ ltree_recv()

Datum ltree_recv ( PG_FUNCTION_ARGS )

Definition at line 230 of file ltree_io.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    int         version = pq_getmsgint(buf, 1);
    char       *str;
    int         nbytes;
    ltree      *res;
 
    if (version != 1)
        elog(ERROR, "unsupported ltree version number %d", version);
 
    str = pq_getmsgtext(buf, buf->len - buf->cursor, &nbytes);
    res = parse_ltree(str, NULL);
    pfree(str);
 
    PG_RETURN_POINTER(res);
}

References buf, elog, ERROR, fb(), parse_ltree(), pfree(), PG_GETARG_POINTER, PG_RETURN_POINTER, pq_getmsgint(), pq_getmsgtext(), and str.

◆ ltree_send()

Datum ltree_send ( PG_FUNCTION_ARGS )

Definition at line 205 of file ltree_io.c.

{
    ltree      *in = PG_GETARG_LTREE_P(0);
    StringInfoData buf;
    int         version = 1;
    char       *res = deparse_ltree(in);
 
    pq_begintypsend(&buf);
    pq_sendint8(&buf, version);
    pq_sendtext(&buf, res, strlen(res));
    pfree(res);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, deparse_ltree(), fb(), pfree(), PG_GETARG_LTREE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), and pq_sendtext().

◆ parse_lquery()

static lquery * parse_lquery	(	const char *	buf,
		struct Node *	escontext
	)

static

Definition at line 269 of file ltree_io.c.

{
    const char *ptr;
    int         num = 0,
                totallen = 0,
                numOR = 0;
    int         state = LQPRS_WAITLEVEL;
    lquery     *result;
    nodeitem   *lptr = NULL;
    lquery_level *cur,
               *curqlevel,
               *tmpql;
    lquery_variant *lrptr = NULL;
    bool        hasnot = false;
    bool        wasbad = false;
    int         charlen;
    int         pos = 1;        /* character position for error messages */
 
#define UNCHAR ereturn(escontext, NULL,\
                       errcode(ERRCODE_SYNTAX_ERROR), \
                       errmsg("lquery syntax error at character %d", \
                              pos))
 
    ptr = buf;
    while (*ptr)
    {
        charlen = pg_mblen_cstr(ptr);
 
        if (t_iseq(ptr, '.'))
            num++;
        else if (t_iseq(ptr, '|'))
            numOR++;
 
        ptr += charlen;
    }
 
    num++;
    if (num > LQUERY_MAX_LEVELS)
        ereturn(escontext, NULL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of lquery items (%d) exceeds the maximum allowed (%d)",
                        num, LQUERY_MAX_LEVELS)));
    curqlevel = tmpql = (lquery_level *) palloc0(ITEMSIZE * num);
    ptr = buf;
    while (*ptr)
    {
        charlen = pg_mblen_cstr(ptr);
 
        switch (state)
        {
            case LQPRS_WAITLEVEL:
                if (ISLABEL(ptr))
                {
                    GETVAR(curqlevel) = lptr = palloc0_array(nodeitem, numOR + 1);
                    lptr->start = ptr;
                    state = LQPRS_WAITDELIM;
                    curqlevel->numvar = 1;
                }
                else if (t_iseq(ptr, '!'))
                {
                    GETVAR(curqlevel) = lptr = palloc0_array(nodeitem, numOR + 1);
                    lptr->start = ptr + 1;
                    lptr->wlen = -1;    /* compensate for counting ! below */
                    state = LQPRS_WAITDELIM;
                    curqlevel->numvar = 1;
                    curqlevel->flag |= LQL_NOT;
                    hasnot = true;
                }
                else if (t_iseq(ptr, '*'))
                    state = LQPRS_WAITOPEN;
                else
                    UNCHAR;
                break;
            case LQPRS_WAITVAR:
                if (ISLABEL(ptr))
                {
                    lptr++;
                    lptr->start = ptr;
                    state = LQPRS_WAITDELIM;
                    if (pg_add_u16_overflow(curqlevel->numvar, 1, &curqlevel->numvar))
                        ereturn(escontext, NULL,
                                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                 errmsg("lquery level has too many variants"),
                                 errdetail("Number of variants exceeds the maximum allowed (%d).",
                                           PG_UINT16_MAX)));
                }
                else
                    UNCHAR;
                break;
            case LQPRS_WAITDELIM:
                if (t_iseq(ptr, '@'))
                {
                    lptr->flag |= LVAR_INCASE;
                    curqlevel->flag |= LVAR_INCASE;
                }
                else if (t_iseq(ptr, '*'))
                {
                    lptr->flag |= LVAR_ANYEND;
                    curqlevel->flag |= LVAR_ANYEND;
                }
                else if (t_iseq(ptr, '%'))
                {
                    lptr->flag |= LVAR_SUBLEXEME;
                    curqlevel->flag |= LVAR_SUBLEXEME;
                }
                else if (t_iseq(ptr, '|'))
                {
                    if (!finish_nodeitem(lptr, ptr, true, pos, escontext))
                        return NULL;
                    state = LQPRS_WAITVAR;
                }
                else if (t_iseq(ptr, '{'))
                {
                    if (!finish_nodeitem(lptr, ptr, true, pos, escontext))
                        return NULL;
                    curqlevel->flag |= LQL_COUNT;
                    state = LQPRS_WAITFNUM;
                }
                else if (t_iseq(ptr, '.'))
                {
                    if (!finish_nodeitem(lptr, ptr, true, pos, escontext))
                        return NULL;
                    state = LQPRS_WAITLEVEL;
                    curqlevel = NEXTLEV(curqlevel);
                }
                else if (ISLABEL(ptr))
                {
                    /* disallow more chars after a flag */
                    if (lptr->flag)
                        UNCHAR;
                }
                else
                    UNCHAR;
                break;
            case LQPRS_WAITOPEN:
                if (t_iseq(ptr, '{'))
                    state = LQPRS_WAITFNUM;
                else if (t_iseq(ptr, '.'))
                {
                    /* We only get here for '*', so these are correct defaults */
                    curqlevel->low = 0;
                    curqlevel->high = LTREE_MAX_LEVELS;
                    curqlevel = NEXTLEV(curqlevel);
                    state = LQPRS_WAITLEVEL;
                }
                else
                    UNCHAR;
                break;
            case LQPRS_WAITFNUM:
                if (t_iseq(ptr, ','))
                    state = LQPRS_WAITSNUM;
                else if (isdigit((unsigned char) *ptr))
                {
                    int         low = atoi(ptr);
 
                    if (low < 0 || low > LTREE_MAX_LEVELS)
                        ereturn(escontext, NULL,
                                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                 errmsg("lquery syntax error"),
                                 errdetail("Low limit (%d) exceeds the maximum allowed (%d), at character %d.",
                                           low, LTREE_MAX_LEVELS, pos)));
 
                    curqlevel->low = (uint16) low;
                    state = LQPRS_WAITND;
                }
                else
                    UNCHAR;
                break;
            case LQPRS_WAITSNUM:
                if (isdigit((unsigned char) *ptr))
                {
                    int         high = atoi(ptr);
 
                    if (high < 0 || high > LTREE_MAX_LEVELS)
                        ereturn(escontext, NULL,
                                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                                 errmsg("lquery syntax error"),
                                 errdetail("High limit (%d) exceeds the maximum allowed (%d), at character %d.",
                                           high, LTREE_MAX_LEVELS, pos)));
                    else if (curqlevel->low > high)
                        ereturn(escontext, NULL,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("lquery syntax error"),
                                 errdetail("Low limit (%d) is greater than high limit (%d), at character %d.",
                                           curqlevel->low, high, pos)));
 
                    curqlevel->high = (uint16) high;
                    state = LQPRS_WAITCLOSE;
                }
                else if (t_iseq(ptr, '}'))
                {
                    curqlevel->high = LTREE_MAX_LEVELS;
                    state = LQPRS_WAITEND;
                }
                else
                    UNCHAR;
                break;
            case LQPRS_WAITCLOSE:
                if (t_iseq(ptr, '}'))
                    state = LQPRS_WAITEND;
                else if (!isdigit((unsigned char) *ptr))
                    UNCHAR;
                break;
            case LQPRS_WAITND:
                if (t_iseq(ptr, '}'))
                {
                    curqlevel->high = curqlevel->low;
                    state = LQPRS_WAITEND;
                }
                else if (t_iseq(ptr, ','))
                    state = LQPRS_WAITSNUM;
                else if (!isdigit((unsigned char) *ptr))
                    UNCHAR;
                break;
            case LQPRS_WAITEND:
                if (t_iseq(ptr, '.'))
                {
                    state = LQPRS_WAITLEVEL;
                    curqlevel = NEXTLEV(curqlevel);
                }
                else
                    UNCHAR;
                break;
            default:
                elog(ERROR, "internal error in lquery parser");
        }
 
        ptr += charlen;
        if (state == LQPRS_WAITDELIM)
            lptr->wlen++;
        pos++;
    }
 
    if (state == LQPRS_WAITDELIM)
    {
        if (!finish_nodeitem(lptr, ptr, true, pos, escontext))
            return NULL;
    }
    else if (state == LQPRS_WAITOPEN)
        curqlevel->high = LTREE_MAX_LEVELS;
    else if (state != LQPRS_WAITEND)
        ereturn(escontext, NULL,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("lquery syntax error"),
                 errdetail("Unexpected end of input.")));
 
    curqlevel = tmpql;
    totallen = LQUERY_HDRSIZE;
    while ((char *) curqlevel - (char *) tmpql < num * ITEMSIZE)
    {
        totallen += LQL_HDRSIZE;
        if (curqlevel->numvar)
        {
            lptr = GETVAR(curqlevel);
            while (lptr - GETVAR(curqlevel) < curqlevel->numvar)
            {
                totallen += MAXALIGN(LVAR_HDRSIZE + lptr->len);
                lptr++;
            }
        }
        curqlevel = NEXTLEV(curqlevel);
    }
 
    result = (lquery *) palloc0(totallen);
    SET_VARSIZE(result, totallen);
    result->numlevel = num;
    result->firstgood = 0;
    result->flag = 0;
    if (hasnot)
        result->flag |= LQUERY_HASNOT;
    cur = LQUERY_FIRST(result);
    curqlevel = tmpql;
    while ((char *) curqlevel - (char *) tmpql < num * ITEMSIZE)
    {
        memcpy(cur, curqlevel, LQL_HDRSIZE);
        cur->totallen = LQL_HDRSIZE;
        if (curqlevel->numvar)
        {
            lrptr = LQL_FIRST(cur);
            lptr = GETVAR(curqlevel);
            while (lptr - GETVAR(curqlevel) < curqlevel->numvar)
            {
                int         newlen = cur->totallen + MAXALIGN(LVAR_HDRSIZE + lptr->len);
 
                if (newlen > PG_UINT16_MAX)
                    ereturn(escontext, NULL,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("lquery level is too large"),
                             errdetail("Total size of level exceeds the maximum allowed (%d bytes).",
                                       PG_UINT16_MAX)));
                cur->totallen = (uint16) newlen;
 
                lrptr->len = lptr->len;
                lrptr->flag = lptr->flag;
                lrptr->val = ltree_crc32_sz(lptr->start, lptr->len);
                memcpy(lrptr->name, lptr->start, lptr->len);
                lptr++;
                lrptr = LVAR_NEXT(lrptr);
            }
            pfree(GETVAR(curqlevel));
            if (cur->numvar > 1 || cur->flag != 0)
            {
                /* Not a simple match */
                wasbad = true;
            }
            else if (wasbad == false)
            {
                /* count leading simple matches */
                (result->firstgood)++;
            }
        }
        else
        {
            /* '*', so this isn't a simple match */
            wasbad = true;
        }
        curqlevel = NEXTLEV(curqlevel);
        cur = LQL_NEXT(cur);
    }
 
    pfree(tmpql);
    return result;
 
#undef UNCHAR
}

References buf, cur, elog, ereturn, errcode(), errdetail(), errmsg, ERROR, fb(), finish_nodeitem(), state::flag, GETVAR, ISLABEL, ITEMSIZE, LQL_COUNT, LQL_FIRST, LQL_HDRSIZE, LQL_NEXT, LQL_NOT, LQPRS_WAITCLOSE, LQPRS_WAITDELIM, LQPRS_WAITEND, LQPRS_WAITFNUM, LQPRS_WAITLEVEL, LQPRS_WAITND, LQPRS_WAITOPEN, LQPRS_WAITSNUM, LQPRS_WAITVAR, LQUERY_FIRST, LQUERY_HASNOT, LQUERY_HDRSIZE, LQUERY_MAX_LEVELS, ltree_crc32_sz(), LTREE_MAX_LEVELS, LVAR_ANYEND, LVAR_HDRSIZE, LVAR_INCASE, LVAR_NEXT, LVAR_SUBLEXEME, MAXALIGN, memcpy(), NEXTLEV, palloc0(), palloc0_array, pfree(), pg_add_u16_overflow(), pg_mblen_cstr(), PG_UINT16_MAX, result, SET_VARSIZE(), t_iseq, and UNCHAR.

Referenced by lquery_in(), and lquery_recv().

◆ parse_ltree()

static ltree * parse_ltree	(	const char *	buf,
		struct Node *	escontext
	)

static

Definition at line 37 of file ltree_io.c.

{
    const char *ptr;
    nodeitem   *list,
               *lptr;
    int         num = 0,
                totallen = 0;
    int         state = LTPRS_WAITNAME;
    ltree      *result;
    ltree_level *curlevel;
    int         charlen;
    int         pos = 1;        /* character position for error messages */
 
#define UNCHAR ereturn(escontext, NULL,\
                       errcode(ERRCODE_SYNTAX_ERROR), \
                       errmsg("ltree syntax error at character %d", \
                              pos))
 
    ptr = buf;
    while (*ptr)
    {
        charlen = pg_mblen_cstr(ptr);
        if (t_iseq(ptr, '.'))
            num++;
        ptr += charlen;
    }
 
    if (num + 1 > LTREE_MAX_LEVELS)
        ereturn(escontext, NULL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("number of ltree labels (%d) exceeds the maximum allowed (%d)",
                        num + 1, LTREE_MAX_LEVELS)));
    list = lptr = palloc_array(nodeitem, num + 1);
    ptr = buf;
    while (*ptr)
    {
        charlen = pg_mblen_cstr(ptr);
 
        switch (state)
        {
            case LTPRS_WAITNAME:
                if (ISLABEL(ptr))
                {
                    lptr->start = ptr;
                    lptr->wlen = 0;
                    state = LTPRS_WAITDELIM;
                }
                else
                    UNCHAR;
                break;
            case LTPRS_WAITDELIM:
                if (t_iseq(ptr, '.'))
                {
                    if (!finish_nodeitem(lptr, ptr, false, pos, escontext))
                        return NULL;
                    totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
                    lptr++;
                    state = LTPRS_WAITNAME;
                }
                else if (!ISLABEL(ptr))
                    UNCHAR;
                break;
            default:
                elog(ERROR, "internal error in ltree parser");
        }
 
        ptr += charlen;
        lptr->wlen++;
        pos++;
    }
 
    if (state == LTPRS_WAITDELIM)
    {
        if (!finish_nodeitem(lptr, ptr, false, pos, escontext))
            return NULL;
        totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
        lptr++;
    }
    else if (!(state == LTPRS_WAITNAME && lptr == list))
        ereturn(escontext, NULL,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("ltree syntax error"),
                 errdetail("Unexpected end of input.")));
 
    result = (ltree *) palloc0(LTREE_HDRSIZE + totallen);
    SET_VARSIZE(result, LTREE_HDRSIZE + totallen);
    result->numlevel = lptr - list;
    curlevel = LTREE_FIRST(result);
    lptr = list;
    while (lptr - list < result->numlevel)
    {
        curlevel->len = (uint16) lptr->len;
        memcpy(curlevel->name, lptr->start, lptr->len);
        curlevel = LEVEL_NEXT(curlevel);
        lptr++;
    }
 
    pfree(list);
    return result;
 
#undef UNCHAR
}

References buf, elog, ereturn, errcode(), errdetail(), errmsg, ERROR, fb(), finish_nodeitem(), ISLABEL, LEVEL_HDRSIZE, LEVEL_NEXT, LTPRS_WAITDELIM, LTPRS_WAITNAME, LTREE_FIRST, LTREE_HDRSIZE, LTREE_MAX_LEVELS, MAXALIGN, memcpy(), palloc0(), palloc_array, pfree(), pg_mblen_cstr(), result, SET_VARSIZE(), t_iseq, and UNCHAR.

Referenced by ltree_in(), and ltree_recv().

◆ PG_FUNCTION_INFO_V1() [1/8]

PG_FUNCTION_INFO_V1 ( lquery_in )

◆ PG_FUNCTION_INFO_V1() [2/8]

PG_FUNCTION_INFO_V1 ( lquery_out )

◆ PG_FUNCTION_INFO_V1() [3/8]

PG_FUNCTION_INFO_V1 ( lquery_recv )

◆ PG_FUNCTION_INFO_V1() [4/8]

PG_FUNCTION_INFO_V1 ( lquery_send )

◆ PG_FUNCTION_INFO_V1() [5/8]

PG_FUNCTION_INFO_V1 ( ltree_in )

◆ PG_FUNCTION_INFO_V1() [6/8]

PG_FUNCTION_INFO_V1 ( ltree_out )

◆ PG_FUNCTION_INFO_V1() [7/8]

PG_FUNCTION_INFO_V1 ( ltree_recv )

◆ PG_FUNCTION_INFO_V1() [8/8]

PG_FUNCTION_INFO_V1 ( ltree_send )

Data Structures

Macros

Functions

Macro Definition Documentation

◆ GETVAR

◆ ITEMSIZE

◆ LQPRS_WAITCLOSE

◆ LQPRS_WAITDELIM

◆ LQPRS_WAITEND

◆ LQPRS_WAITFNUM

◆ LQPRS_WAITLEVEL

◆ LQPRS_WAITND

◆ LQPRS_WAITOPEN

◆ LQPRS_WAITSNUM

◆ LQPRS_WAITVAR

◆ LTPRS_WAITDELIM

◆ LTPRS_WAITNAME

◆ NEXTLEV

◆ UNCHAR [1/2]

◆ UNCHAR [2/2]

Function Documentation

◆ deparse_lquery()

◆ deparse_ltree()

◆ finish_nodeitem()

◆ lquery_in()

◆ lquery_out()

◆ lquery_recv()

◆ lquery_send()

◆ ltree_in()

◆ ltree_out()

◆ ltree_recv()

◆ ltree_send()

◆ parse_lquery()

◆ parse_ltree()

◆ PG_FUNCTION_INFO_V1() [1/8]

◆ PG_FUNCTION_INFO_V1() [2/8]

◆ PG_FUNCTION_INFO_V1() [3/8]

◆ PG_FUNCTION_INFO_V1() [4/8]

◆ PG_FUNCTION_INFO_V1() [5/8]

◆ PG_FUNCTION_INFO_V1() [6/8]

◆ PG_FUNCTION_INFO_V1() [7/8]

◆ PG_FUNCTION_INFO_V1() [8/8]