ltree_io.c File Reference

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

Include dependency graph for ltree_io.c:

Go to the source code of this file.

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 259 of file ltree_io.c.

ITEMSIZE

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

Definition at line 260 of file ltree_io.c.

LQPRS_WAITCLOSE

#define LQPRS_WAITCLOSE   6

Definition at line 254 of file ltree_io.c.

LQPRS_WAITDELIM

#define LQPRS_WAITDELIM   1

Definition at line 249 of file ltree_io.c.

LQPRS_WAITEND

#define LQPRS_WAITEND   7

Definition at line 255 of file ltree_io.c.

LQPRS_WAITFNUM

#define LQPRS_WAITFNUM   3

Definition at line 251 of file ltree_io.c.

LQPRS_WAITLEVEL

#define LQPRS_WAITLEVEL   0

Definition at line 248 of file ltree_io.c.

LQPRS_WAITND

#define LQPRS_WAITND   5

Definition at line 253 of file ltree_io.c.

LQPRS_WAITOPEN

#define LQPRS_WAITOPEN   2

Definition at line 250 of file ltree_io.c.

LQPRS_WAITSNUM

#define LQPRS_WAITSNUM   4

Definition at line 252 of file ltree_io.c.

LQPRS_WAITVAR

#define LQPRS_WAITVAR   8

Definition at line 256 of file ltree_io.c.

LTPRS_WAITDELIM

#define LTPRS_WAITDELIM   1

Definition at line 25 of file ltree_io.c.

LTPRS_WAITNAME

#define LTPRS_WAITNAME   0

Definition at line 24 of file ltree_io.c.

NEXTLEV

#define NEXTLEV

(

x

)

( (lquery_level*)( ((char*)(x)) + ITEMSIZE) )

Definition at line 261 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 627 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, lquery_variant::flag, lquery_level::flag, lquery_level::high, i, if(), j, lquery_variant::len, lquery_level::low, LQL_COUNT, LQL_FIRST, LQL_NEXT, LQL_NOT, LQUERY_FIRST, LTREE_MAX_LEVELS, LVAR_ANYEND, LVAR_INCASE, LVAR_NEXT, LVAR_SUBLEXEME, lquery_variant::name, lquery::numlevel, lquery_level::numvar, palloc(), sprintf, and lquery_level::totallen.

Referenced by lquery_out(), and lquery_send().

deparse_ltree()

static char * deparse_ltree ( const ltree *  in )

static

Definition at line 144 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, i, ltree_level::len, LEVEL_NEXT, LTREE_FIRST, ltree_level::name, 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 585 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(), nodeitem::len, LTREE_LABEL_MAX_CHARS, nodeitem::start, and nodeitem::wlen.

Referenced by parse_lquery(), and parse_ltree().

lquery_in()

Datum lquery_in

(

PG_FUNCTION_ARGS

)

Definition at line 744 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, parse_lquery(), PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_POINTER.

lquery_out()

Datum lquery_out

(

PG_FUNCTION_ARGS

)

Definition at line 757 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 799 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, 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 774 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(), 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 174 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, 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 187 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 229 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, 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 204 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(), 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 268 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(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(ptr);
 
        switch (state)
        {
            case LQPRS_WAITLEVEL:
                if (ISLABEL(ptr))
                {
                    GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
                    lptr->start = ptr;
                    state = LQPRS_WAITDELIM;
                    curqlevel->numvar = 1;
                }
                else if (t_iseq(ptr, '!'))
                {
                    GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(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;
                    curqlevel->numvar++;
                }
                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)
            {
                cur->totallen += MAXALIGN(LVAR_HDRSIZE + lptr->len);
                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, finish_nodeitem(), lquery::firstgood, lquery_variant::flag, lquery_level::flag, lquery::flag, nodeitem::flag, GETVAR, lquery_level::high, ISLABEL, ITEMSIZE, lquery_variant::len, nodeitem::len, lquery_level::low, 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, lquery_variant::name, NEXTLEV, lquery::numlevel, lquery_level::numvar, palloc0(), pfree(), pg_mblen(), SET_VARSIZE(), nodeitem::start, t_iseq, UNCHAR, lquery_variant::val, and nodeitem::wlen.

Referenced by lquery_in(), and lquery_recv().

parse_ltree()

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

static

Definition at line 36 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(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 = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
    ptr = buf;
    while (*ptr)
    {
        charlen = pg_mblen(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, finish_nodeitem(), ISLABEL, ltree_level::len, nodeitem::len, LEVEL_HDRSIZE, LEVEL_NEXT, sort-test::list, LTPRS_WAITDELIM, LTPRS_WAITNAME, LTREE_FIRST, LTREE_HDRSIZE, LTREE_MAX_LEVELS, MAXALIGN, ltree_level::name, ltree::numlevel, palloc(), palloc0(), pfree(), pg_mblen(), SET_VARSIZE(), nodeitem::start, t_iseq, UNCHAR, and nodeitem::wlen.

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

)