ltxtquery_io.c File Reference

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

Include dependency graph for ltxtquery_io.c:

Go to the source code of this file.

Data Structures
struct	NODE
struct	QPRS_STATE
struct	INFIX

Macros
#define	WAITOPERAND   1
#define	INOPERAND   2
#define	WAITOPERATOR   3
#define	STACKDEPTH   32
#define	RESIZEBUF(inf, addsize)

Typedefs
typedef struct NODE	NODE

Functions
static int32	gettoken_query (QPRS_STATE *state, int32 *val, int32 *lenval, char **strval, uint16 *flag)
static bool	pushquery (QPRS_STATE *state, int32 type, int32 val, int32 distance, int32 lenval, uint16 flag)
static bool	pushval_asis (QPRS_STATE *state, int type, char *strval, int lenval, uint16 flag)
static int32	makepol (QPRS_STATE *state)
static void	findoprnd (ITEM *ptr, int32 *pos)
static ltxtquery *	queryin (char *buf, struct Node *escontext)
	PG_FUNCTION_INFO_V1 (ltxtq_in)
Datum	ltxtq_in (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (ltxtq_recv)
Datum	ltxtq_recv (PG_FUNCTION_ARGS)
static void	infix (INFIX *in, bool first)
	PG_FUNCTION_INFO_V1 (ltxtq_out)
Datum	ltxtq_out (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (ltxtq_send)
Datum	ltxtq_send (PG_FUNCTION_ARGS)

Macro Definition Documentation

INOPERAND

#define INOPERAND   2

Definition at line 20 of file ltxtquery_io.c.

RESIZEBUF

#define RESIZEBUF	(		inf,
			addsize
	)

Value:

while( ( (inf)->cur - (inf)->buf ) + (addsize) + 1 >= (inf)->buflen ) \
{ \
    int32 len = (inf)->cur - (inf)->buf; \
    (inf)->buflen *= 2; \
    (inf)->buf = (char*) repalloc( (void*)(inf)->buf, (inf)->buflen ); \
    (inf)->cur = (inf)->buf + len; \
}

Definition at line 458 of file ltxtquery_io.c.

STACKDEPTH

#define STACKDEPTH   32

Definition at line 209 of file ltxtquery_io.c.

WAITOPERAND

#define WAITOPERAND   1

Definition at line 19 of file ltxtquery_io.c.

WAITOPERATOR

#define WAITOPERATOR   3

Definition at line 21 of file ltxtquery_io.c.

Typedef Documentation

NODE

typedef struct NODE NODE

Function Documentation

findoprnd()

static void findoprnd ( ITEM *  ptr, int32 *  pos  )

static

Definition at line 298 of file ltxtquery_io.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
    {
        ptr[*pos].left = 0;
        (*pos)++;
    }
    else if (ptr[*pos].val == (int32) '!')
    {
        ptr[*pos].left = 1;
        (*pos)++;
        findoprnd(ptr, pos);
    }
    else
    {
        ITEM       *curitem = &ptr[*pos];
        int32       tmp = *pos;
 
        (*pos)++;
        findoprnd(ptr, pos);
        curitem->left = *pos - tmp;
        findoprnd(ptr, pos);
    }
}

References check_stack_depth(), ITEM::left, type, VAL, val, and VALTRUE.

Referenced by queryin().

gettoken_query()

static int32 gettoken_query ( QPRS_STATE *  state, int32 *  val, int32 *  lenval, char **  strval, uint16 *  flag  )

static

Definition at line 61 of file ltxtquery_io.c.

{
    int         charlen;
 
    for (;;)
    {
        charlen = pg_mblen(state->buf);
 
        switch (state->state)
        {
            case WAITOPERAND:
                if (t_iseq(state->buf, '!'))
                {
                    (state->buf)++;
                    *val = (int32) '!';
                    return OPR;
                }
                else if (t_iseq(state->buf, '('))
                {
                    state->count++;
                    (state->buf)++;
                    return OPEN;
                }
                else if (ISLABEL(state->buf))
                {
                    state->state = INOPERAND;
                    *strval = state->buf;
                    *lenval = charlen;
                    *flag = 0;
                }
                else if (!t_isspace(state->buf))
                    ereturn(state->escontext, ERR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("operand syntax error")));
                break;
            case INOPERAND:
                if (ISLABEL(state->buf))
                {
                    if (*flag)
                        ereturn(state->escontext, ERR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("modifiers syntax error")));
                    *lenval += charlen;
                }
                else if (t_iseq(state->buf, '%'))
                    *flag |= LVAR_SUBLEXEME;
                else if (t_iseq(state->buf, '@'))
                    *flag |= LVAR_INCASE;
                else if (t_iseq(state->buf, '*'))
                    *flag |= LVAR_ANYEND;
                else
                {
                    state->state = WAITOPERATOR;
                    return VAL;
                }
                break;
            case WAITOPERATOR:
                if (t_iseq(state->buf, '&') || t_iseq(state->buf, '|'))
                {
                    state->state = WAITOPERAND;
                    *val = (int32) *(state->buf);
                    (state->buf)++;
                    return OPR;
                }
                else if (t_iseq(state->buf, ')'))
                {
                    (state->buf)++;
                    state->count--;
                    return (state->count < 0) ? ERR : CLOSE;
                }
                else if (*(state->buf) == '\0')
                {
                    return (state->count) ? ERR : END;
                }
                else if (!t_iseq(state->buf, ' '))
                {
                    return ERR;
                }
                break;
            default:
                return ERR;
                break;
        }
 
        state->buf += charlen;
    }
 
    /* should not get here */
}

References CLOSE, END, ereturn, ERR, errcode(), errmsg(), flag(), INOPERAND, ISLABEL, LVAR_ANYEND, LVAR_INCASE, LVAR_SUBLEXEME, OPEN, OPR, pg_mblen(), t_iseq, t_isspace(), VAL, val, WAITOPERAND, and WAITOPERATOR.

Referenced by makepol().

infix()

static void infix ( INFIX *  in, bool  first  )

static

Definition at line 472 of file ltxtquery_io.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->curpol->type == VAL)
    {
        char       *op = in->op + in->curpol->distance;
 
        RESIZEBUF(in, in->curpol->length * 2 + 5);
        while (*op)
        {
            *(in->cur) = *op;
            op++;
            in->cur++;
        }
        if (in->curpol->flag & LVAR_SUBLEXEME)
        {
            *(in->cur) = '%';
            in->cur++;
        }
        if (in->curpol->flag & LVAR_INCASE)
        {
            *(in->cur) = '@';
            in->cur++;
        }
        if (in->curpol->flag & LVAR_ANYEND)
        {
            *(in->cur) = '*';
            in->cur++;
        }
        *(in->cur) = '\0';
        in->curpol++;
    }
    else if (in->curpol->val == (int32) '!')
    {
        bool        isopr = false;
 
        RESIZEBUF(in, 1);
        *(in->cur) = '!';
        in->cur++;
        *(in->cur) = '\0';
        in->curpol++;
        if (in->curpol->type == OPR)
        {
            isopr = true;
            RESIZEBUF(in, 2);
            sprintf(in->cur, "( ");
            in->cur = strchr(in->cur, '\0');
        }
        infix(in, isopr);
        if (isopr)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
    else
    {
        int32       op = in->curpol->val;
        INFIX       nrm;
 
        in->curpol++;
        if (op == (int32) '|' && !first)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, "( ");
            in->cur = strchr(in->cur, '\0');
        }
 
        nrm.curpol = in->curpol;
        nrm.op = in->op;
        nrm.buflen = 16;
        nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
 
        /* get right operand */
        infix(&nrm, false);
 
        /* get & print left operand */
        in->curpol = nrm.curpol;
        infix(in, false);
 
        /* print operator & right operand */
        RESIZEBUF(in, 3 + (nrm.cur - nrm.buf));
        sprintf(in->cur, " %c %s", op, nrm.buf);
        in->cur = strchr(in->cur, '\0');
        pfree(nrm.buf);
 
        if (op == (int32) '|' && !first)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
}

References INFIX::buf, INFIX::buflen, check_stack_depth(), INFIX::cur, INFIX::curpol, ITEM::distance, ITEM::flag, ITEM::length, LVAR_ANYEND, LVAR_INCASE, LVAR_SUBLEXEME, INFIX::op, OPR, palloc(), pfree(), RESIZEBUF, sprintf, ITEM::type, ITEM::val, and VAL.

Referenced by ltxtq_out(), and ltxtq_send().

ltxtq_in()

Datum ltxtq_in

(

PG_FUNCTION_ARGS

)

Definition at line 409 of file ltxtquery_io.c.

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

References PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_POINTER, queryin(), and res.

ltxtq_out()

Datum ltxtq_out

(

PG_FUNCTION_ARGS

)

Definition at line 572 of file ltxtquery_io.c.

{
    ltxtquery  *query = PG_GETARG_LTXTQUERY_P(0);
    INFIX       nrm;
 
    if (query->size == 0)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("syntax error"),
                 errdetail("Empty query.")));
 
    nrm.curpol = GETQUERY(query);
    nrm.buflen = 32;
    nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
    *(nrm.cur) = '\0';
    nrm.op = GETOPERAND(query);
    infix(&nrm, true);
 
    PG_RETURN_POINTER(nrm.buf);
}

References INFIX::buf, INFIX::buflen, INFIX::cur, INFIX::curpol, ereport, errcode(), errdetail(), errmsg(), ERROR, GETOPERAND, GETQUERY, infix(), INFIX::op, palloc(), PG_GETARG_LTXTQUERY_P, PG_RETURN_POINTER, and ltxtquery::size.

ltxtq_recv()

Datum ltxtq_recv

(

PG_FUNCTION_ARGS

)

Definition at line 428 of file ltxtquery_io.c.

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

References buf, elog, ERROR, pfree(), PG_GETARG_POINTER, PG_RETURN_POINTER, pq_getmsgint(), pq_getmsgtext(), queryin(), res, and str.

ltxtq_send()

Datum ltxtq_send

(

PG_FUNCTION_ARGS

)

Definition at line 603 of file ltxtquery_io.c.

{
    ltxtquery  *query = PG_GETARG_LTXTQUERY_P(0);
    StringInfoData buf;
    int         version = 1;
    INFIX       nrm;
 
    if (query->size == 0)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("syntax error"),
                 errdetail("Empty query.")));
 
    nrm.curpol = GETQUERY(query);
    nrm.buflen = 32;
    nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
    *(nrm.cur) = '\0';
    nrm.op = GETOPERAND(query);
    infix(&nrm, true);
 
    pq_begintypsend(&buf);
    pq_sendint8(&buf, version);
    pq_sendtext(&buf, nrm.buf, strlen(nrm.buf));
    pfree(nrm.buf);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References INFIX::buf, buf, INFIX::buflen, INFIX::cur, INFIX::curpol, ereport, errcode(), errdetail(), errmsg(), ERROR, GETOPERAND, GETQUERY, infix(), INFIX::op, palloc(), pfree(), PG_GETARG_LTXTQUERY_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint8(), pq_sendtext(), and ltxtquery::size.

makepol()

static int32 makepol ( QPRS_STATE *  state )

static

Definition at line 214 of file ltxtquery_io.c.

{
    int32       val = 0,
                type;
    int32       lenval = 0;
    char       *strval = NULL;
    int32       stack[STACKDEPTH];
    int32       lenstack = 0;
    uint16      flag = 0;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    while ((type = gettoken_query(state, &val, &lenval, &strval, &flag)) != END)
    {
        switch (type)
        {
            case VAL:
                if (!pushval_asis(state, VAL, strval, lenval, flag))
                    return ERR;
                while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
                                    stack[lenstack - 1] == (int32) '!'))
                {
                    lenstack--;
                    if (!pushquery(state, OPR, stack[lenstack], 0, 0, 0))
                        return ERR;
                }
                break;
            case OPR:
                if (lenstack && val == (int32) '|')
                {
                    if (!pushquery(state, OPR, val, 0, 0, 0))
                        return ERR;
                }
                else
                {
                    if (lenstack == STACKDEPTH)
                        /* internal error */
                        elog(ERROR, "stack too short");
                    stack[lenstack] = val;
                    lenstack++;
                }
                break;
            case OPEN:
                if (makepol(state) == ERR)
                    return ERR;
                while (lenstack && (stack[lenstack - 1] == (int32) '&' ||
                                    stack[lenstack - 1] == (int32) '!'))
                {
                    lenstack--;
                    if (!pushquery(state, OPR, stack[lenstack], 0, 0, 0))
                        return ERR;
                }
                break;
            case CLOSE:
                while (lenstack)
                {
                    lenstack--;
                    if (!pushquery(state, OPR, stack[lenstack], 0, 0, 0))
                        return ERR;
                };
                return END;
                break;
            case ERR:
                if (SOFT_ERROR_OCCURRED(state->escontext))
                    return ERR;
                /* fall through */
            default:
                ereturn(state->escontext, ERR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("syntax error")));
 
        }
    }
    while (lenstack)
    {
        lenstack--;
        if (!pushquery(state, OPR, stack[lenstack], 0, 0, 0))
            return ERR;
    };
    return END;
}

References check_stack_depth(), CLOSE, elog, END, ereturn, ERR, errcode(), errmsg(), ERROR, flag(), gettoken_query(), OPEN, OPR, pushquery(), pushval_asis(), SOFT_ERROR_OCCURRED, STACKDEPTH, type, VAL, and val.

Referenced by queryin().

PG_FUNCTION_INFO_V1() [1/4]

PG_FUNCTION_INFO_V1

(

ltxtq_in

)

PG_FUNCTION_INFO_V1() [2/4]

PG_FUNCTION_INFO_V1

(

ltxtq_out

)

PG_FUNCTION_INFO_V1() [3/4]

PG_FUNCTION_INFO_V1

(

ltxtq_recv

)

PG_FUNCTION_INFO_V1() [4/4]

PG_FUNCTION_INFO_V1

(

ltxtq_send

)

pushquery()

static bool pushquery ( QPRS_STATE *  state, int32  type, int32  val, int32  distance, int32  lenval, uint16  flag  )

static

Definition at line 155 of file ltxtquery_io.c.

{
    NODE       *tmp = (NODE *) palloc(sizeof(NODE));
 
    tmp->type = type;
    tmp->val = val;
    tmp->flag = flag;
    if (distance > 0xffff)
        ereturn(state->escontext, false,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("value is too big")));
    if (lenval > 0xff)
        ereturn(state->escontext, false,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("operand is too long")));
    tmp->distance = distance;
    tmp->length = lenval;
    tmp->next = state->str;
    state->str = tmp;
    state->num++;
    return true;
}

References NODE::distance, ereturn, errcode(), errmsg(), NODE::flag, flag(), NODE::length, NODE::next, palloc(), NODE::type, type, NODE::val, and val.

Referenced by makepol(), and pushval_asis().

pushval_asis()

static bool pushval_asis ( QPRS_STATE *  state, int  type, char *  strval, int  lenval, uint16  flag  )

static

Definition at line 182 of file ltxtquery_io.c.

{
    if (lenval > 0xffff)
        ereturn(state->escontext, false,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("word is too long")));
 
    if (!pushquery(state, type, ltree_crc32_sz(strval, lenval),
                   state->curop - state->op, lenval, flag))
        return false;
 
    while (state->curop - state->op + lenval + 1 >= state->lenop)
    {
        int32       tmp = state->curop - state->op;
 
        state->lenop *= 2;
        state->op = (char *) repalloc(state->op, state->lenop);
        state->curop = state->op + tmp;
    }
    memcpy(state->curop, strval, lenval);
    state->curop += lenval;
    *(state->curop) = '\0';
    state->curop++;
    state->sumlen += lenval + 1;
    return true;
}

References ereturn, errcode(), errmsg(), flag(), ltree_crc32_sz(), pushquery(), repalloc(), and type.

Referenced by makepol().

queryin()

static ltxtquery* queryin ( char *  buf, struct Node *  escontext  )

static

Definition at line 331 of file ltxtquery_io.c.

{
    QPRS_STATE  state;
    int32       i;
    ltxtquery  *query;
    int32       commonlen;
    ITEM       *ptr;
    NODE       *tmp;
    int32       pos = 0;
 
#ifdef BS_DEBUG
    char        pbuf[16384],
               *cur;
#endif
 
    /* init state */
    state.buf = buf;
    state.state = WAITOPERAND;
    state.count = 0;
    state.num = 0;
    state.str = NULL;
    state.escontext = escontext;
 
    /* init list of operand */
    state.sumlen = 0;
    state.lenop = 64;
    state.curop = state.op = (char *) palloc(state.lenop);
    *(state.curop) = '\0';
 
    /* parse query & make polish notation (postfix, but in reverse order) */
    if (makepol(&state) == ERR)
        return NULL;
    if (!state.num)
        ereturn(escontext, NULL,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("syntax error"),
                 errdetail("Empty query.")));
 
    if (LTXTQUERY_TOO_BIG(state.num, state.sumlen))
        ereturn(escontext, NULL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("ltxtquery is too large")));
    commonlen = COMPUTESIZE(state.num, state.sumlen);
 
    query = (ltxtquery *) palloc0(commonlen);
    SET_VARSIZE(query, commonlen);
    query->size = state.num;
    ptr = GETQUERY(query);
 
    /* set item in polish notation */
    for (i = 0; i < state.num; i++)
    {
        ptr[i].type = state.str->type;
        ptr[i].val = state.str->val;
        ptr[i].distance = state.str->distance;
        ptr[i].length = state.str->length;
        ptr[i].flag = state.str->flag;
        tmp = state.str->next;
        pfree(state.str);
        state.str = tmp;
    }
 
    /* set user-friendly operand view */
    memcpy(GETOPERAND(query), state.op, state.sumlen);
    pfree(state.op);
 
    /* set left operand's position for every operator */
    pos = 0;
    findoprnd(ptr, &pos);
 
    return query;
}

References buf, COMPUTESIZE, cur, ITEM::distance, ereturn, ERR, errcode(), errdetail(), errmsg(), findoprnd(), ITEM::flag, state::flag, GETOPERAND, GETQUERY, i, ITEM::length, LTXTQUERY_TOO_BIG, makepol(), state::next, palloc(), palloc0(), pfree(), SET_VARSIZE, ltxtquery::size, ITEM::type, ITEM::val, and WAITOPERAND.

Referenced by ltxtq_in(), and ltxtq_recv().