tsquery.c File Reference

#include "postgres.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/miscnodes.h"
#include "tsearch/ts_locale.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/pg_crc.h"
#include "varatt.h"

Include dependency graph for tsquery.c:

Go to the source code of this file.

Data Structures
struct	TSQueryParserStateData
struct	OperatorElement
struct	INFIX

Macros
#define	STACKDEPTH   32
#define	RESIZEBUF(inf, addsize)

Typedefs
typedef ts_tokentype(*	ts_tokenizer) (TSQueryParserState state, int8 *operator, int *lenval, char **strval, int16 *weight, bool *prefix)
typedef struct OperatorElement	OperatorElement

Enumerations
enum	ts_parserstate { WAITOPERAND = 1 , WAITOPERATOR = 2 , WAITFIRSTOPERAND = 3 }
enum	ts_tokentype {   PT_END = 0 , PT_ERR = 1 , PT_VAL = 2 , PT_OPR = 3 ,   PT_OPEN = 4 , PT_CLOSE = 5 }

Functions
static char *	get_modifiers (char *buf, int16 *weight, bool *prefix)
static bool	parse_phrase_operator (TSQueryParserState pstate, int16 *distance)
static bool	parse_or_operator (TSQueryParserState pstate)
static ts_tokentype	gettoken_query_standard (TSQueryParserState state, int8 *operator, int *lenval, char **strval, int16 *weight, bool *prefix)
static ts_tokentype	gettoken_query_websearch (TSQueryParserState state, int8 *operator, int *lenval, char **strval, int16 *weight, bool *prefix)
static ts_tokentype	gettoken_query_plain (TSQueryParserState state, int8 *operator, int *lenval, char **strval, int16 *weight, bool *prefix)
void	pushOperator (TSQueryParserState state, int8 oper, int16 distance)
static void	pushValue_internal (TSQueryParserState state, pg_crc32 valcrc, int distance, int lenval, int weight, bool prefix)
void	pushValue (TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
void	pushStop (TSQueryParserState state)
static void	pushOpStack (OperatorElement *stack, int *lenstack, int8 op, int16 distance)
static void	cleanOpStack (TSQueryParserState state, OperatorElement *stack, int *lenstack, int8 op)
static void	makepol (TSQueryParserState state, PushFunction pushval, Datum opaque)
static void	findoprnd_recurse (QueryItem *ptr, uint32 *pos, int nnodes, bool *needcleanup)
static void	findoprnd (QueryItem *ptr, int size, bool *needcleanup)
TSQuery	parse_tsquery (char *buf, PushFunction pushval, Datum opaque, int flags, Node *escontext)
static void	pushval_asis (Datum opaque, TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
Datum	tsqueryin (PG_FUNCTION_ARGS)
static void	infix (INFIX *in, int parentPriority, bool rightPhraseOp)
Datum	tsqueryout (PG_FUNCTION_ARGS)
Datum	tsquerysend (PG_FUNCTION_ARGS)
Datum	tsqueryrecv (PG_FUNCTION_ARGS)
Datum	tsquerytree (PG_FUNCTION_ARGS)

Variables
const int	tsearch_op_priority [OP_COUNT]

Macro Definition Documentation

RESIZEBUF

#define RESIZEBUF	(		inf,
			addsize
	)

Value:

while( ( (inf)->cur - (inf)->buf ) + (addsize) + 1 >= (inf)->buflen ) \
{ \
    int 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 977 of file tsquery.c.

STACKDEPTH

#define STACKDEPTH   32

Definition at line 627 of file tsquery.c.

Typedef Documentation

OperatorElement

typedef struct OperatorElement OperatorElement

ts_tokenizer

typedef ts_tokentype(* ts_tokenizer) (TSQueryParserState state, int8 *operator,int *lenval, char **strval, int16 *weight, bool *prefix)

Definition at line 74 of file tsquery.c.

Enumeration Type Documentation

ts_parserstate

enum ts_parserstate

Enumerator
WAITOPERAND
WAITOPERATOR
WAITFIRSTOPERAND

Definition at line 40 of file tsquery.c.

{
    WAITOPERAND = 1,
    WAITOPERATOR = 2,
    WAITFIRSTOPERAND = 3,
} ts_parserstate;

ts_tokentype

enum ts_tokentype

Enumerator
PT_END
PT_ERR
PT_VAL
PT_OPR
PT_OPEN
PT_CLOSE

Definition at line 50 of file tsquery.c.

{
    PT_END = 0,
    PT_ERR = 1,
    PT_VAL = 2,
    PT_OPR = 3,
    PT_OPEN = 4,
    PT_CLOSE = 5,
} ts_tokentype;

Function Documentation

cleanOpStack()

static void cleanOpStack ( TSQueryParserState  state, OperatorElement *  stack, int *  lenstack, int8  op  )

static

Definition at line 648 of file tsquery.c.

{
    int         opPriority = OP_PRIORITY(op);
 
    while (*lenstack)
    {
        /* NOT is right associative unlike to others */
        if ((op != OP_NOT && opPriority > OP_PRIORITY(stack[*lenstack - 1].op)) ||
            (op == OP_NOT && opPriority >= OP_PRIORITY(stack[*lenstack - 1].op)))
            break;
 
        (*lenstack)--;
        pushOperator(state, stack[*lenstack].op,
                     stack[*lenstack].distance);
    }
}

References OP_NOT, OP_PRIORITY, and pushOperator().

Referenced by makepol().

findoprnd()

static void findoprnd ( QueryItem *  ptr, int  size, bool *  needcleanup  )

static

Definition at line 784 of file tsquery.c.

{
    uint32      pos;
 
    *needcleanup = false;
    pos = 0;
    findoprnd_recurse(ptr, &pos, size, needcleanup);
 
    if (pos != size)
        elog(ERROR, "malformed tsquery: extra nodes");
}

References elog, ERROR, findoprnd_recurse(), and size.

Referenced by parse_tsquery(), and tsqueryrecv().

findoprnd_recurse()

static void findoprnd_recurse ( QueryItem *  ptr, uint32 *  pos, int  nnodes, bool *  needcleanup  )

static

Definition at line 726 of file tsquery.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (*pos >= nnodes)
        elog(ERROR, "malformed tsquery: operand not found");
 
    if (ptr[*pos].type == QI_VAL)
    {
        (*pos)++;
    }
    else if (ptr[*pos].type == QI_VALSTOP)
    {
        *needcleanup = true;    /* we'll have to remove stop words */
        (*pos)++;
    }
    else
    {
        Assert(ptr[*pos].type == QI_OPR);
 
        if (ptr[*pos].qoperator.oper == OP_NOT)
        {
            ptr[*pos].qoperator.left = 1;   /* fixed offset */
            (*pos)++;
 
            /* process the only argument */
            findoprnd_recurse(ptr, pos, nnodes, needcleanup);
        }
        else
        {
            QueryOperator *curitem = &ptr[*pos].qoperator;
            int         tmp = *pos; /* save current position */
 
            Assert(curitem->oper == OP_AND ||
                   curitem->oper == OP_OR ||
                   curitem->oper == OP_PHRASE);
 
            (*pos)++;
 
            /* process RIGHT argument */
            findoprnd_recurse(ptr, pos, nnodes, needcleanup);
 
            curitem->left = *pos - tmp; /* set LEFT arg's offset */
 
            /* process LEFT argument */
            findoprnd_recurse(ptr, pos, nnodes, needcleanup);
        }
    }
}

References Assert, check_stack_depth(), elog, ERROR, findoprnd_recurse(), QueryOperator::left, OP_AND, OP_NOT, OP_OR, OP_PHRASE, QueryOperator::oper, QI_OPR, QI_VAL, QI_VALSTOP, QueryItem::qoperator, and type.

Referenced by findoprnd(), and findoprnd_recurse().

get_modifiers()

static char * get_modifiers ( char *  buf, int16 *  weight, bool *  prefix  )

static

Definition at line 114 of file tsquery.c.

{
    *weight = 0;
    *prefix = false;
 
    if (!t_iseq(buf, ':'))
        return buf;
 
    buf++;
    while (*buf && pg_mblen(buf) == 1)
    {
        switch (*buf)
        {
            case 'a':
            case 'A':
                *weight |= 1 << 3;
                break;
            case 'b':
            case 'B':
                *weight |= 1 << 2;
                break;
            case 'c':
            case 'C':
                *weight |= 1 << 1;
                break;
            case 'd':
            case 'D':
                *weight |= 1;
                break;
            case '*':
                *prefix = true;
                break;
            default:
                return buf;
        }
        buf++;
    }
 
    return buf;
}

References buf, pg_mblen(), and t_iseq.

Referenced by gettoken_query_standard().

gettoken_query_plain()

static ts_tokentype gettoken_query_plain ( TSQueryParserState  state, int8 *  operator, int *  lenval, char **  strval, int16 *  weight, bool *  prefix  )

static

Definition at line 510 of file tsquery.c.

{
    *weight = 0;
    *prefix = false;
 
    if (*state->buf == '\0')
        return PT_END;
 
    *strval = state->buf;
    *lenval = strlen(state->buf);
    state->buf += *lenval;
    state->count++;
    return PT_VAL;
}

References PT_END, and PT_VAL.

Referenced by parse_tsquery().

gettoken_query_standard()

static ts_tokentype gettoken_query_standard ( TSQueryParserState  state, int8 *  operator, int *  lenval, char **  strval, int16 *  weight, bool *  prefix  )

static

Definition at line 286 of file tsquery.c.

{
    *weight = 0;
    *prefix = false;
 
    while (true)
    {
        switch (state->state)
        {
            case WAITFIRSTOPERAND:
            case WAITOPERAND:
                if (t_iseq(state->buf, '!'))
                {
                    state->buf++;
                    state->state = WAITOPERAND;
                    *operator = OP_NOT;
                    return PT_OPR;
                }
                else if (t_iseq(state->buf, '('))
                {
                    state->buf++;
                    state->state = WAITOPERAND;
                    state->count++;
                    return PT_OPEN;
                }
                else if (t_iseq(state->buf, ':'))
                {
                    /* generic syntax error message is fine */
                    return PT_ERR;
                }
                else if (!isspace((unsigned char) *state->buf))
                {
                    /*
                     * We rely on the tsvector parser to parse the value for
                     * us
                     */
                    reset_tsvector_parser(state->valstate, state->buf);
                    if (gettoken_tsvector(state->valstate, strval, lenval,
                                          NULL, NULL, &state->buf))
                    {
                        state->buf = get_modifiers(state->buf, weight, prefix);
                        state->state = WAITOPERATOR;
                        return PT_VAL;
                    }
                    else if (SOFT_ERROR_OCCURRED(state->escontext))
                    {
                        /* gettoken_tsvector reported a soft error */
                        return PT_ERR;
                    }
                    else if (state->state == WAITFIRSTOPERAND)
                    {
                        return PT_END;
                    }
                    else
                        ereturn(state->escontext, PT_ERR,
                                (errcode(ERRCODE_SYNTAX_ERROR),
                                 errmsg("no operand in tsquery: \"%s\"",
                                        state->buffer)));
                }
                break;
 
            case WAITOPERATOR:
                if (t_iseq(state->buf, '&'))
                {
                    state->buf++;
                    state->state = WAITOPERAND;
                    *operator = OP_AND;
                    return PT_OPR;
                }
                else if (t_iseq(state->buf, '|'))
                {
                    state->buf++;
                    state->state = WAITOPERAND;
                    *operator = OP_OR;
                    return PT_OPR;
                }
                else if (parse_phrase_operator(state, weight))
                {
                    /* weight var is used as storage for distance */
                    state->state = WAITOPERAND;
                    *operator = OP_PHRASE;
                    return PT_OPR;
                }
                else if (SOFT_ERROR_OCCURRED(state->escontext))
                {
                    /* parse_phrase_operator reported a soft error */
                    return PT_ERR;
                }
                else if (t_iseq(state->buf, ')'))
                {
                    state->buf++;
                    state->count--;
                    return (state->count < 0) ? PT_ERR : PT_CLOSE;
                }
                else if (*state->buf == '\0')
                {
                    return (state->count) ? PT_ERR : PT_END;
                }
                else if (!isspace((unsigned char) *state->buf))
                {
                    return PT_ERR;
                }
                break;
        }
 
        state->buf += pg_mblen(state->buf);
    }
}

References ereturn, errcode(), errmsg(), get_modifiers(), gettoken_tsvector(), OP_AND, OP_NOT, OP_OR, OP_PHRASE, parse_phrase_operator(), pg_mblen(), PT_CLOSE, PT_END, PT_ERR, PT_OPEN, PT_OPR, PT_VAL, reset_tsvector_parser(), SOFT_ERROR_OCCURRED, t_iseq, WAITFIRSTOPERAND, WAITOPERAND, and WAITOPERATOR.

Referenced by parse_tsquery().

gettoken_query_websearch()

static ts_tokentype gettoken_query_websearch ( TSQueryParserState  state, int8 *  operator, int *  lenval, char **  strval, int16 *  weight, bool *  prefix  )

static

Definition at line 398 of file tsquery.c.

{
    *weight = 0;
    *prefix = false;
 
    while (true)
    {
        switch (state->state)
        {
            case WAITFIRSTOPERAND:
            case WAITOPERAND:
                if (t_iseq(state->buf, '-'))
                {
                    state->buf++;
                    state->state = WAITOPERAND;
 
                    *operator = OP_NOT;
                    return PT_OPR;
                }
                else if (t_iseq(state->buf, '"'))
                {
                    /* Everything in quotes is processed as a single token */
 
                    /* skip opening quote */
                    state->buf++;
                    *strval = state->buf;
 
                    /* iterate to the closing quote or end of the string */
                    while (*state->buf != '\0' && !t_iseq(state->buf, '"'))
                        state->buf++;
                    *lenval = state->buf - *strval;
 
                    /* skip closing quote if not end of the string */
                    if (*state->buf != '\0')
                        state->buf++;
 
                    state->state = WAITOPERATOR;
                    state->count++;
                    return PT_VAL;
                }
                else if (ISOPERATOR(state->buf))
                {
                    /* ignore, else gettoken_tsvector() will raise an error */
                    state->buf++;
                    state->state = WAITOPERAND;
                    continue;
                }
                else if (!isspace((unsigned char) *state->buf))
                {
                    /*
                     * We rely on the tsvector parser to parse the value for
                     * us
                     */
                    reset_tsvector_parser(state->valstate, state->buf);
                    if (gettoken_tsvector(state->valstate, strval, lenval,
                                          NULL, NULL, &state->buf))
                    {
                        state->state = WAITOPERATOR;
                        return PT_VAL;
                    }
                    else if (SOFT_ERROR_OCCURRED(state->escontext))
                    {
                        /* gettoken_tsvector reported a soft error */
                        return PT_ERR;
                    }
                    else if (state->state == WAITFIRSTOPERAND)
                    {
                        return PT_END;
                    }
                    else
                    {
                        /* finally, we have to provide an operand */
                        pushStop(state);
                        return PT_END;
                    }
                }
                break;
 
            case WAITOPERATOR:
                if (*state->buf == '\0')
                {
                    return PT_END;
                }
                else if (parse_or_operator(state))
                {
                    state->state = WAITOPERAND;
                    *operator = OP_OR;
                    return PT_OPR;
                }
                else if (ISOPERATOR(state->buf))
                {
                    /* ignore other operators in this state too */
                    state->buf++;
                    continue;
                }
                else if (!isspace((unsigned char) *state->buf))
                {
                    /* insert implicit AND between operands */
                    state->state = WAITOPERAND;
                    *operator = OP_AND;
                    return PT_OPR;
                }
                break;
        }
 
        state->buf += pg_mblen(state->buf);
    }
}

References gettoken_tsvector(), ISOPERATOR, OP_AND, OP_NOT, OP_OR, parse_or_operator(), pg_mblen(), PT_END, PT_ERR, PT_OPR, PT_VAL, pushStop(), reset_tsvector_parser(), SOFT_ERROR_OCCURRED, t_iseq, WAITFIRSTOPERAND, WAITOPERAND, and WAITOPERATOR.

Referenced by parse_tsquery().

infix()

static void infix ( INFIX *  in, int  parentPriority, bool  rightPhraseOp  )

static

Definition at line 991 of file tsquery.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->curpol->type == QI_VAL)
    {
        QueryOperand *curpol = &in->curpol->qoperand;
        char       *op = in->op + curpol->distance;
        int         clen;
 
        RESIZEBUF(in, curpol->length * (pg_database_encoding_max_length() + 1) + 2 + 6);
        *(in->cur) = '\'';
        in->cur++;
        while (*op)
        {
            if (t_iseq(op, '\''))
            {
                *(in->cur) = '\'';
                in->cur++;
            }
            else if (t_iseq(op, '\\'))
            {
                *(in->cur) = '\\';
                in->cur++;
            }
            COPYCHAR(in->cur, op);
 
            clen = pg_mblen(op);
            op += clen;
            in->cur += clen;
        }
        *(in->cur) = '\'';
        in->cur++;
        if (curpol->weight || curpol->prefix)
        {
            *(in->cur) = ':';
            in->cur++;
            if (curpol->prefix)
            {
                *(in->cur) = '*';
                in->cur++;
            }
            if (curpol->weight & (1 << 3))
            {
                *(in->cur) = 'A';
                in->cur++;
            }
            if (curpol->weight & (1 << 2))
            {
                *(in->cur) = 'B';
                in->cur++;
            }
            if (curpol->weight & (1 << 1))
            {
                *(in->cur) = 'C';
                in->cur++;
            }
            if (curpol->weight & 1)
            {
                *(in->cur) = 'D';
                in->cur++;
            }
        }
        *(in->cur) = '\0';
        in->curpol++;
    }
    else if (in->curpol->qoperator.oper == OP_NOT)
    {
        int         priority = QO_PRIORITY(in->curpol);
 
        if (priority < parentPriority)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, "( ");
            in->cur = strchr(in->cur, '\0');
        }
        RESIZEBUF(in, 1);
        *(in->cur) = '!';
        in->cur++;
        *(in->cur) = '\0';
        in->curpol++;
 
        infix(in, priority, false);
        if (priority < parentPriority)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
    else
    {
        int8        op = in->curpol->qoperator.oper;
        int         priority = QO_PRIORITY(in->curpol);
        int16       distance = in->curpol->qoperator.distance;
        INFIX       nrm;
        bool        needParenthesis = false;
 
        in->curpol++;
        if (priority < parentPriority ||
        /* phrase operator depends on order */
            (op == OP_PHRASE && rightPhraseOp))
        {
            needParenthesis = true;
            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, priority, (op == OP_PHRASE));
 
        /* get & print left operand */
        in->curpol = nrm.curpol;
        infix(in, priority, false);
 
        /* print operator & right operand */
        RESIZEBUF(in, 3 + (2 + 10 /* distance */ ) + (nrm.cur - nrm.buf));
        switch (op)
        {
            case OP_OR:
                sprintf(in->cur, " | %s", nrm.buf);
                break;
            case OP_AND:
                sprintf(in->cur, " & %s", nrm.buf);
                break;
            case OP_PHRASE:
                if (distance != 1)
                    sprintf(in->cur, " <%d> %s", distance, nrm.buf);
                else
                    sprintf(in->cur, " <-> %s", nrm.buf);
                break;
            default:
                /* OP_NOT is handled in above if-branch */
                elog(ERROR, "unrecognized operator type: %d", op);
        }
        in->cur = strchr(in->cur, '\0');
        pfree(nrm.buf);
 
        if (needParenthesis)
        {
            RESIZEBUF(in, 2);
            sprintf(in->cur, " )");
            in->cur = strchr(in->cur, '\0');
        }
    }
}

References INFIX::buf, INFIX::buflen, check_stack_depth(), COPYCHAR, INFIX::cur, INFIX::curpol, ITEM::distance, QueryOperand::distance, elog, ERROR, infix(), QueryOperand::length, INFIX::op, TSQueryParserStateData::op, OP_AND, OP_NOT, OP_OR, OP_PHRASE, palloc(), pfree(), pg_database_encoding_max_length(), pg_mblen(), QueryOperand::prefix, QI_VAL, QO_PRIORITY, RESIZEBUF, sprintf, t_iseq, ITEM::type, and QueryOperand::weight.

Referenced by infix(), tsqueryout(), and tsquerytree().

makepol()

static void makepol ( TSQueryParserState  state, PushFunction  pushval, Datum  opaque  )

static

Definition at line 672 of file tsquery.c.

{
    int8        operator = 0;
    ts_tokentype type;
    int         lenval = 0;
    char       *strval = NULL;
    OperatorElement opstack[STACKDEPTH];
    int         lenstack = 0;
    int16       weight = 0;
    bool        prefix;
 
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    while ((type = state->gettoken(state, &operator,
                                   &lenval, &strval,
                                   &weight, &prefix)) != PT_END)
    {
        switch (type)
        {
            case PT_VAL:
                pushval(opaque, state, strval, lenval, weight, prefix);
                break;
            case PT_OPR:
                cleanOpStack(state, opstack, &lenstack, operator);
                pushOpStack(opstack, &lenstack, operator, weight);
                break;
            case PT_OPEN:
                makepol(state, pushval, opaque);
                break;
            case PT_CLOSE:
                cleanOpStack(state, opstack, &lenstack, OP_OR /* lowest */ );
                return;
            case PT_ERR:
            default:
                /* don't overwrite a soft error saved by gettoken function */
                if (!SOFT_ERROR_OCCURRED(state->escontext))
                    errsave(state->escontext,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("syntax error in tsquery: \"%s\"",
                                    state->buffer)));
                return;
        }
        /* detect soft error in pushval or recursion */
        if (SOFT_ERROR_OCCURRED(state->escontext))
            return;
    }
 
    cleanOpStack(state, opstack, &lenstack, OP_OR /* lowest */ );
}

References check_stack_depth(), cleanOpStack(), errcode(), errmsg(), errsave, makepol(), OP_OR, PT_CLOSE, PT_END, PT_ERR, PT_OPEN, PT_OPR, PT_VAL, pushOpStack(), SOFT_ERROR_OCCURRED, STACKDEPTH, and type.

Referenced by makepol(), and parse_tsquery().

parse_or_operator()

static bool parse_or_operator ( TSQueryParserState  pstate )

static

Definition at line 244 of file tsquery.c.

{
    char       *ptr = pstate->buf;
 
    /* it should begin with "OR" literal */
    if (pg_strncasecmp(ptr, "or", 2) != 0)
        return false;
 
    ptr += 2;
 
    /*
     * it shouldn't be a part of any word but somewhere later it should be
     * some operand
     */
    if (*ptr == '\0')           /* no operand */
        return false;
 
    /* it shouldn't be a part of any word */
    if (t_iseq(ptr, '-') || t_iseq(ptr, '_') || t_isalnum(ptr))
        return false;
 
    for (;;)
    {
        ptr += pg_mblen(ptr);
 
        if (*ptr == '\0')       /* got end of string without operand */
            return false;
 
        /*
         * Suppose, we found an operand, but could be a not correct operand.
         * So we still treat OR literal as operation with possibly incorrect
         * operand and will not search it as lexeme
         */
        if (!isspace((unsigned char) *ptr))
            break;
    }
 
    pstate->buf += 2;
    return true;
}

References TSQueryParserStateData::buf, pg_mblen(), pg_strncasecmp(), t_isalnum(), and t_iseq.

Referenced by gettoken_query_websearch().

parse_phrase_operator()

static bool parse_phrase_operator ( TSQueryParserState  pstate, int16 *  distance  )

static

Definition at line 165 of file tsquery.c.

{
    enum
    {
        PHRASE_OPEN = 0,
        PHRASE_DIST,
        PHRASE_CLOSE,
        PHRASE_FINISH
    }           state = PHRASE_OPEN;
    char       *ptr = pstate->buf;
    char       *endptr;
    long        l = 1;          /* default distance */
 
    while (*ptr)
    {
        switch (state)
        {
            case PHRASE_OPEN:
                if (t_iseq(ptr, '<'))
                {
                    state = PHRASE_DIST;
                    ptr++;
                }
                else
                    return false;
                break;
 
            case PHRASE_DIST:
                if (t_iseq(ptr, '-'))
                {
                    state = PHRASE_CLOSE;
                    ptr++;
                    continue;
                }
 
                if (!isdigit((unsigned char) *ptr))
                    return false;
 
                errno = 0;
                l = strtol(ptr, &endptr, 10);
                if (ptr == endptr)
                    return false;
                else if (errno == ERANGE || l < 0 || l > MAXENTRYPOS)
                    ereturn(pstate->escontext, false,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("distance in phrase operator must be an integer value between zero and %d inclusive",
                                    MAXENTRYPOS)));
                else
                {
                    state = PHRASE_CLOSE;
                    ptr = endptr;
                }
                break;
 
            case PHRASE_CLOSE:
                if (t_iseq(ptr, '>'))
                {
                    state = PHRASE_FINISH;
                    ptr++;
                }
                else
                    return false;
                break;
 
            case PHRASE_FINISH:
                *distance = (int16) l;
                pstate->buf = ptr;
                return true;
        }
    }
 
    return false;
}

References TSQueryParserStateData::buf, ereturn, errcode(), errmsg(), TSQueryParserStateData::escontext, MAXENTRYPOS, and t_iseq.

Referenced by gettoken_query_standard().

parse_tsquery()

TSQuery parse_tsquery	(	char *	buf,
		PushFunction	pushval,
		Datum	opaque,
		int	flags,
		Node *	escontext
	)

Definition at line 817 of file tsquery.c.

{
    struct TSQueryParserStateData state;
    int         i;
    TSQuery     query;
    int         commonlen;
    QueryItem  *ptr;
    ListCell   *cell;
    bool        noisy;
    bool        needcleanup;
    int         tsv_flags = P_TSV_OPR_IS_DELIM | P_TSV_IS_TSQUERY;
 
    /* plain should not be used with web */
    Assert((flags & (P_TSQ_PLAIN | P_TSQ_WEB)) != (P_TSQ_PLAIN | P_TSQ_WEB));
 
    /* select suitable tokenizer */
    if (flags & P_TSQ_PLAIN)
        state.gettoken = gettoken_query_plain;
    else if (flags & P_TSQ_WEB)
    {
        state.gettoken = gettoken_query_websearch;
        tsv_flags |= P_TSV_IS_WEB;
    }
    else
        state.gettoken = gettoken_query_standard;
 
    /* emit nuisance NOTICEs only if not doing soft errors */
    noisy = !(escontext && IsA(escontext, ErrorSaveContext));
 
    /* init state */
    state.buffer = buf;
    state.buf = buf;
    state.count = 0;
    state.state = WAITFIRSTOPERAND;
    state.polstr = NIL;
    state.escontext = escontext;
 
    /* init value parser's state */
    state.valstate = init_tsvector_parser(state.buffer, tsv_flags, 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) */
    makepol(&state, pushval, opaque);
 
    close_tsvector_parser(state.valstate);
 
    if (SOFT_ERROR_OCCURRED(escontext))
        return NULL;
 
    if (state.polstr == NIL)
    {
        if (noisy)
            ereport(NOTICE,
                    (errmsg("text-search query doesn't contain lexemes: \"%s\"",
                            state.buffer)));
        query = (TSQuery) palloc(HDRSIZETQ);
        SET_VARSIZE(query, HDRSIZETQ);
        query->size = 0;
        return query;
    }
 
    if (TSQUERY_TOO_BIG(list_length(state.polstr), state.sumlen))
        ereturn(escontext, NULL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("tsquery is too large")));
    commonlen = COMPUTESIZE(list_length(state.polstr), state.sumlen);
 
    /* Pack the QueryItems in the final TSQuery struct to return to caller */
    query = (TSQuery) palloc0(commonlen);
    SET_VARSIZE(query, commonlen);
    query->size = list_length(state.polstr);
    ptr = GETQUERY(query);
 
    /* Copy QueryItems to TSQuery */
    i = 0;
    foreach(cell, state.polstr)
    {
        QueryItem  *item = (QueryItem *) lfirst(cell);
 
        switch (item->type)
        {
            case QI_VAL:
                memcpy(&ptr[i], item, sizeof(QueryOperand));
                break;
            case QI_VALSTOP:
                ptr[i].type = QI_VALSTOP;
                break;
            case QI_OPR:
                memcpy(&ptr[i], item, sizeof(QueryOperator));
                break;
            default:
                elog(ERROR, "unrecognized QueryItem type: %d", item->type);
        }
        i++;
    }
 
    /* Copy all the operand strings to TSQuery */
    memcpy(GETOPERAND(query), state.op, state.sumlen);
    pfree(state.op);
 
    /*
     * Set left operand pointers for every operator.  While we're at it,
     * detect whether there are any QI_VALSTOP nodes.
     */
    findoprnd(ptr, query->size, &needcleanup);
 
    /*
     * If there are QI_VALSTOP nodes, delete them and simplify the tree.
     */
    if (needcleanup)
        query = cleanup_tsquery_stopwords(query, noisy);
 
    return query;
}

References Assert, buf, cleanup_tsquery_stopwords(), close_tsvector_parser(), COMPUTESIZE, elog, ereport, ereturn, errcode(), errmsg(), ERROR, TSQueryParserStateData::escontext, findoprnd(), GETOPERAND, GETQUERY, gettoken_query_plain(), gettoken_query_standard(), gettoken_query_websearch(), HDRSIZETQ, i, init_tsvector_parser(), IsA, lfirst, list_length(), makepol(), NIL, NOTICE, P_TSQ_PLAIN, P_TSQ_WEB, P_TSV_IS_TSQUERY, P_TSV_IS_WEB, P_TSV_OPR_IS_DELIM, palloc(), palloc0(), pfree(), QI_OPR, QI_VAL, QI_VALSTOP, SET_VARSIZE, TSQueryData::size, SOFT_ERROR_OCCURRED, TSQUERY_TOO_BIG, QueryItem::type, and WAITFIRSTOPERAND.

Referenced by phraseto_tsquery_byid(), plainto_tsquery_byid(), to_tsquery_byid(), tsqueryin(), and websearch_to_tsquery_byid().

pushOperator()

void pushOperator	(	TSQueryParserState	state,
		int8	oper,
		int16	distance
	)

Definition at line 531 of file tsquery.c.

{
    QueryOperator *tmp;
 
    Assert(oper == OP_NOT || oper == OP_AND || oper == OP_OR || oper == OP_PHRASE);
 
    tmp = (QueryOperator *) palloc0(sizeof(QueryOperator));
    tmp->type = QI_OPR;
    tmp->oper = oper;
    tmp->distance = (oper == OP_PHRASE) ? distance : 0;
    /* left is filled in later with findoprnd */
 
    state->polstr = lcons(tmp, state->polstr);
}

References Assert, QueryOperator::distance, lcons(), OP_AND, OP_NOT, OP_OR, OP_PHRASE, oper(), QueryOperator::oper, palloc0(), QI_OPR, and QueryOperator::type.

Referenced by cleanOpStack(), and pushval_morph().

pushOpStack()

static void pushOpStack ( OperatorElement *  stack, int *  lenstack, int8  op, int16  distance  )

static

Definition at line 636 of file tsquery.c.

{
    if (*lenstack == STACKDEPTH)    /* internal error */
        elog(ERROR, "tsquery stack too small");
 
    stack[*lenstack].op = op;
    stack[*lenstack].distance = distance;
 
    (*lenstack)++;
}

References OperatorElement::distance, elog, ERROR, OperatorElement::op, and STACKDEPTH.

Referenced by makepol().

pushStop()

void pushStop

(

TSQueryParserState

state

)

Definition at line 616 of file tsquery.c.

{
    QueryOperand *tmp;
 
    tmp = (QueryOperand *) palloc0(sizeof(QueryOperand));
    tmp->type = QI_VALSTOP;
 
    state->polstr = lcons(tmp, state->polstr);
}

References lcons(), palloc0(), QI_VALSTOP, and QueryOperand::type.

Referenced by gettoken_query_websearch(), and pushval_morph().

pushval_asis()

static void pushval_asis ( Datum  opaque, TSQueryParserState  state, char *  strval, int  lenval, int16  weight, bool  prefix  )

static

Definition at line 942 of file tsquery.c.

{
    pushValue(state, strval, lenval, weight, prefix);
}

References pushValue().

Referenced by tsqueryin().

pushValue()

void pushValue	(	TSQueryParserState	state,
		char *	strval,
		int	lenval,
		int16	weight,
		bool	prefix
	)

Definition at line 580 of file tsquery.c.

{
    pg_crc32    valcrc;
 
    if (lenval >= MAXSTRLEN)
        ereturn(state->escontext,,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("word is too long in tsquery: \"%s\"",
                        state->buffer)));
 
    INIT_LEGACY_CRC32(valcrc);
    COMP_LEGACY_CRC32(valcrc, strval, lenval);
    FIN_LEGACY_CRC32(valcrc);
    pushValue_internal(state, valcrc, state->curop - state->op, lenval, weight, prefix);
 
    /* append the value string to state.op, enlarging buffer if needed first */
    while (state->curop - state->op + lenval + 1 >= state->lenop)
    {
        int         used = state->curop - state->op;
 
        state->lenop *= 2;
        state->op = (char *) repalloc(state->op, state->lenop);
        state->curop = state->op + used;
    }
    memcpy(state->curop, strval, lenval);
    state->curop += lenval;
    *(state->curop) = '\0';
    state->curop++;
    state->sumlen += lenval + 1 /* \0 */ ;
}

References COMP_LEGACY_CRC32, ereturn, errcode(), errmsg(), FIN_LEGACY_CRC32, INIT_LEGACY_CRC32, MAXSTRLEN, pushValue_internal(), and repalloc().

Referenced by pushval_asis(), and pushval_morph().

pushValue_internal()

static void pushValue_internal ( TSQueryParserState  state, pg_crc32  valcrc, int  distance, int  lenval, int  weight, bool  prefix  )

static

Definition at line 547 of file tsquery.c.

{
    QueryOperand *tmp;
 
    if (distance >= MAXSTRPOS)
        ereturn(state->escontext,,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("value is too big in tsquery: \"%s\"",
                        state->buffer)));
    if (lenval >= MAXSTRLEN)
        ereturn(state->escontext,,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("operand is too long in tsquery: \"%s\"",
                        state->buffer)));
 
    tmp = (QueryOperand *) palloc0(sizeof(QueryOperand));
    tmp->type = QI_VAL;
    tmp->weight = weight;
    tmp->prefix = prefix;
    tmp->valcrc = (int32) valcrc;
    tmp->length = lenval;
    tmp->distance = distance;
 
    state->polstr = lcons(tmp, state->polstr);
}

References QueryOperand::distance, ereturn, errcode(), errmsg(), lcons(), QueryOperand::length, MAXSTRLEN, MAXSTRPOS, palloc0(), QueryOperand::prefix, QI_VAL, QueryOperand::type, QueryOperand::valcrc, and QueryOperand::weight.

Referenced by pushValue().

tsqueryin()

Datum tsqueryin

(

PG_FUNCTION_ARGS

)

Definition at line 952 of file tsquery.c.

{
    char       *in = PG_GETARG_CSTRING(0);
    Node       *escontext = fcinfo->context;
 
    PG_RETURN_TSQUERY(parse_tsquery(in,
                                    pushval_asis,
                                    PointerGetDatum(NULL),
                                    0,
                                    escontext));
}

References TSQueryParserStateData::escontext, parse_tsquery(), PG_GETARG_CSTRING, PG_RETURN_TSQUERY, PointerGetDatum(), and pushval_asis().

tsqueryout()

Datum tsqueryout

(

PG_FUNCTION_ARGS

)

Definition at line 1146 of file tsquery.c.

{
    TSQuery     query = PG_GETARG_TSQUERY(0);
    INFIX       nrm;
 
    if (query->size == 0)
    {
        char       *b = palloc(1);
 
        *b = '\0';
        PG_RETURN_POINTER(b);
    }
    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, -1 /* lowest priority */ , false);
 
    PG_FREE_IF_COPY(query, 0);
    PG_RETURN_CSTRING(nrm.buf);
}

References b, INFIX::buf, INFIX::buflen, INFIX::cur, INFIX::curpol, GETOPERAND, GETQUERY, infix(), INFIX::op, palloc(), PG_FREE_IF_COPY, PG_GETARG_TSQUERY, PG_RETURN_CSTRING, PG_RETURN_POINTER, and TSQueryData::size.

tsqueryrecv()

Datum tsqueryrecv

(

PG_FUNCTION_ARGS

)

Definition at line 1226 of file tsquery.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    TSQuery     query;
    int         i,
                len;
    QueryItem  *item;
    int         datalen;
    char       *ptr;
    uint32      size;
    const char **operands;
    bool        needcleanup;
 
    size = pq_getmsgint(buf, sizeof(uint32));
    if (size > (MaxAllocSize / sizeof(QueryItem)))
        elog(ERROR, "invalid size of tsquery");
 
    /* Allocate space to temporarily hold operand strings */
    operands = palloc(size * sizeof(char *));
 
    /* Allocate space for all the QueryItems. */
    len = HDRSIZETQ + sizeof(QueryItem) * size;
    query = (TSQuery) palloc0(len);
    query->size = size;
    item = GETQUERY(query);
 
    datalen = 0;
    for (i = 0; i < size; i++)
    {
        item->type = (int8) pq_getmsgint(buf, sizeof(int8));
 
        if (item->type == QI_VAL)
        {
            size_t      val_len;    /* length after recoding to server
                                     * encoding */
            uint8       weight;
            uint8       prefix;
            const char *val;
            pg_crc32    valcrc;
 
            weight = (uint8) pq_getmsgint(buf, sizeof(uint8));
            prefix = (uint8) pq_getmsgint(buf, sizeof(uint8));
            val = pq_getmsgstring(buf);
            val_len = strlen(val);
 
            /* Sanity checks */
 
            if (weight > 0xF)
                elog(ERROR, "invalid tsquery: invalid weight bitmap");
 
            if (val_len > MAXSTRLEN)
                elog(ERROR, "invalid tsquery: operand too long");
 
            if (datalen > MAXSTRPOS)
                elog(ERROR, "invalid tsquery: total operand length exceeded");
 
            /* Looks valid. */
 
            INIT_LEGACY_CRC32(valcrc);
            COMP_LEGACY_CRC32(valcrc, val, val_len);
            FIN_LEGACY_CRC32(valcrc);
 
            item->qoperand.weight = weight;
            item->qoperand.prefix = (prefix) ? true : false;
            item->qoperand.valcrc = (int32) valcrc;
            item->qoperand.length = val_len;
            item->qoperand.distance = datalen;
 
            /*
             * Operand strings are copied to the final struct after this loop;
             * here we just collect them to an array
             */
            operands[i] = val;
 
            datalen += val_len + 1; /* + 1 for the '\0' terminator */
        }
        else if (item->type == QI_OPR)
        {
            int8        oper;
 
            oper = (int8) pq_getmsgint(buf, sizeof(int8));
            if (oper != OP_NOT && oper != OP_OR && oper != OP_AND && oper != OP_PHRASE)
                elog(ERROR, "invalid tsquery: unrecognized operator type %d",
                     (int) oper);
            if (i == size - 1)
                elog(ERROR, "invalid pointer to right operand");
 
            item->qoperator.oper = oper;
            if (oper == OP_PHRASE)
                item->qoperator.distance = (int16) pq_getmsgint(buf, sizeof(int16));
        }
        else
            elog(ERROR, "unrecognized tsquery node type: %d", item->type);
 
        item++;
    }
 
    /* Enlarge buffer to make room for the operand values. */
    query = (TSQuery) repalloc(query, len + datalen);
    item = GETQUERY(query);
    ptr = GETOPERAND(query);
 
    /*
     * Fill in the left-pointers. Checks that the tree is well-formed as a
     * side-effect.
     */
    findoprnd(item, size, &needcleanup);
 
    /* Can't have found any QI_VALSTOP nodes */
    Assert(!needcleanup);
 
    /* Copy operands to output struct */
    for (i = 0; i < size; i++)
    {
        if (item->type == QI_VAL)
        {
            memcpy(ptr, operands[i], item->qoperand.length + 1);
            ptr += item->qoperand.length + 1;
        }
        item++;
    }
 
    pfree(operands);
 
    Assert(ptr - GETOPERAND(query) == datalen);
 
    SET_VARSIZE(query, len + datalen);
 
    PG_RETURN_TSQUERY(query);
}

References Assert, buf, COMP_LEGACY_CRC32, QueryOperand::distance, QueryOperator::distance, elog, ERROR, FIN_LEGACY_CRC32, findoprnd(), GETOPERAND, GETQUERY, HDRSIZETQ, i, INIT_LEGACY_CRC32, len, QueryOperand::length, MaxAllocSize, MAXSTRLEN, MAXSTRPOS, OP_AND, OP_NOT, OP_OR, OP_PHRASE, oper(), QueryOperator::oper, palloc(), palloc0(), pfree(), PG_GETARG_POINTER, PG_RETURN_TSQUERY, pq_getmsgint(), pq_getmsgstring(), QueryOperand::prefix, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, repalloc(), SET_VARSIZE, size, TSQueryData::size, QueryItem::type, val, QueryOperand::valcrc, and QueryOperand::weight.

tsquerysend()

Datum tsquerysend

(

PG_FUNCTION_ARGS

)

Definition at line 1188 of file tsquery.c.

{
    TSQuery     query = PG_GETARG_TSQUERY(0);
    StringInfoData buf;
    int         i;
    QueryItem  *item = GETQUERY(query);
 
    pq_begintypsend(&buf);
 
    pq_sendint32(&buf, query->size);
    for (i = 0; i < query->size; i++)
    {
        pq_sendint8(&buf, item->type);
 
        switch (item->type)
        {
            case QI_VAL:
                pq_sendint8(&buf, item->qoperand.weight);
                pq_sendint8(&buf, item->qoperand.prefix);
                pq_sendstring(&buf, GETOPERAND(query) + item->qoperand.distance);
                break;
            case QI_OPR:
                pq_sendint8(&buf, item->qoperator.oper);
                if (item->qoperator.oper == OP_PHRASE)
                    pq_sendint16(&buf, item->qoperator.distance);
                break;
            default:
                elog(ERROR, "unrecognized tsquery node type: %d", item->type);
        }
        item++;
    }
 
    PG_FREE_IF_COPY(query, 0);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, QueryOperand::distance, QueryOperator::distance, elog, ERROR, GETOPERAND, GETQUERY, i, OP_PHRASE, QueryOperator::oper, PG_FREE_IF_COPY, PG_GETARG_TSQUERY, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint16(), pq_sendint32(), pq_sendint8(), pq_sendstring(), QueryOperand::prefix, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, TSQueryData::size, QueryItem::type, and QueryOperand::weight.

tsquerytree()

Datum tsquerytree

(

PG_FUNCTION_ARGS

)

Definition at line 1362 of file tsquery.c.

{
    TSQuery     query = PG_GETARG_TSQUERY(0);
    INFIX       nrm;
    text       *res;
    QueryItem  *q;
    int         len;
 
    if (query->size == 0)
    {
        res = (text *) palloc(VARHDRSZ);
        SET_VARSIZE(res, VARHDRSZ);
        PG_RETURN_POINTER(res);
    }
 
    q = clean_NOT(GETQUERY(query), &len);
 
    if (!q)
    {
        res = cstring_to_text("T");
    }
    else
    {
        nrm.curpol = q;
        nrm.buflen = 32;
        nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
        *(nrm.cur) = '\0';
        nrm.op = GETOPERAND(query);
        infix(&nrm, -1, false);
        res = cstring_to_text_with_len(nrm.buf, nrm.cur - nrm.buf);
        pfree(q);
    }
 
    PG_FREE_IF_COPY(query, 0);
 
    PG_RETURN_TEXT_P(res);
}

References INFIX::buf, INFIX::buflen, clean_NOT(), cstring_to_text(), cstring_to_text_with_len(), INFIX::cur, INFIX::curpol, GETOPERAND, GETQUERY, infix(), len, INFIX::op, palloc(), pfree(), PG_FREE_IF_COPY, PG_GETARG_TSQUERY, PG_RETURN_POINTER, PG_RETURN_TEXT_P, res, SET_VARSIZE, TSQueryData::size, and VARHDRSZ.

Variable Documentation

tsearch_op_priority

const int tsearch_op_priority[OP_COUNT]

Initial value:

=
{
    4,                          
    2,                          
    1,                          
    3                           
}

Definition at line 29 of file tsquery.c.