ts_utils.h File Reference

#include "nodes/pg_list.h"
#include "tsearch/ts_public.h"
#include "tsearch/ts_type.h"

Include dependency graph for ts_utils.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ParsedWord
struct	ParsedText
struct	ExecPhraseData
struct	QTNode

Macros
#define	P_TSV_OPR_IS_DELIM   (1 << 0)
#define	P_TSV_IS_TSQUERY   (1 << 1)
#define	P_TSV_IS_WEB   (1 << 2)
#define	ISOPERATOR(x)
#define	P_TSQ_PLAIN   (1 << 0)
#define	P_TSQ_WEB   (1 << 1)
#define	TS_EXEC_EMPTY   (0x00)
#define	TS_EXEC_SKIP_NOT   (0x01)
#define	TS_EXEC_PHRASE_NO_POS   (0x02)
#define	TSearchStrategyNumber   1
#define	TSearchWithClassStrategyNumber   2
#define	QTN_NEEDFREE   0x01
#define	QTN_NOCHANGE   0x02
#define	QTN_WORDFREE   0x04
#define	TSQS_SIGLEN   (sizeof(TSQuerySign)*BITS_PER_BYTE)
#define	PG_RETURN_TSQUERYSIGN(X)   return TSQuerySignGetDatum(X)
#define	PG_GETARG_TSQUERYSIGN(n)   DatumGetTSQuerySign(PG_GETARG_DATUM(n))

Typedefs
typedef struct TSVectorParseStateData *	TSVectorParseState
typedef struct TSQueryParserStateData *	TSQueryParserState
typedef void(*	PushFunction) (Datum opaque, TSQueryParserState state, char *token, int tokenlen, int16 tokenweights, bool prefix)
typedef struct ExecPhraseData	ExecPhraseData
typedef TSTernaryValue(*	TSExecuteCallback) (void *arg, QueryOperand *val, ExecPhraseData *data)
typedef struct QTNode	QTNode
typedef uint64	TSQuerySign

Enumerations
enum	TSTernaryValue { TS_NO , TS_YES , TS_MAYBE }

Functions
TSVectorParseState	init_tsvector_parser (char *input, int flags, Node *escontext)
void	reset_tsvector_parser (TSVectorParseState state, char *input)
bool	gettoken_tsvector (TSVectorParseState state, char **strval, int *lenval, WordEntryPos **pos_ptr, int *poslen, char **endptr)
void	close_tsvector_parser (TSVectorParseState state)
TSQuery	parse_tsquery (char *buf, PushFunction pushval, Datum opaque, int flags, Node *escontext)
void	pushValue (TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
void	pushStop (TSQueryParserState state)
void	pushOperator (TSQueryParserState state, int8 oper, int16 distance)
void	parsetext (Oid cfgId, ParsedText *prs, char *buf, int32 buflen)
void	hlparsetext (Oid cfgId, HeadlineParsedText *prs, TSQuery query, char *buf, int32 buflen)
text *	generateHeadline (HeadlineParsedText *prs)
bool	TS_execute (QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
TSTernaryValue	TS_execute_ternary (QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
List *	TS_execute_locations (QueryItem *curitem, void *arg, uint32 flags, TSExecuteCallback chkcond)
bool	tsquery_requires_match (QueryItem *curitem)
TSVector	make_tsvector (ParsedText *prs)
int32	tsCompareString (char *a, int lena, char *b, int lenb, bool prefix)
QueryItem *	clean_NOT (QueryItem *ptr, int32 *len)
TSQuery	cleanup_tsquery_stopwords (TSQuery in, bool noisy)
static Datum	TSQuerySignGetDatum (TSQuerySign X)
static TSQuerySign	DatumGetTSQuerySign (Datum X)
QTNode *	QT2QTN (QueryItem *in, char *operand)
TSQuery	QTN2QT (QTNode *in)
void	QTNFree (QTNode *in)
void	QTNSort (QTNode *in)
void	QTNTernary (QTNode *in)
void	QTNBinary (QTNode *in)
int	QTNodeCompare (QTNode *an, QTNode *bn)
QTNode *	QTNCopy (QTNode *in)
void	QTNClearFlags (QTNode *in, uint32 flags)
bool	QTNEq (QTNode *a, QTNode *b)
TSQuerySign	makeTSQuerySign (TSQuery a)
QTNode *	findsubquery (QTNode *root, QTNode *ex, QTNode *subs, bool *isfind)

Macro Definition Documentation

ISOPERATOR

#define ISOPERATOR

(

x

)

Value:

    ( pg_mblen(x) == 1 && ( *(x) == '!' ||  \
                            *(x) == '&' ||  \
                            *(x) == '|' ||  \
                            *(x) == '(' ||  \
                            *(x) == ')' ||  \
                            *(x) == '<'     \
                          ) )

Definition at line 43 of file ts_utils.h.

P_TSQ_PLAIN

#define P_TSQ_PLAIN   (1 << 0)

Definition at line 64 of file ts_utils.h.

P_TSQ_WEB

#define P_TSQ_WEB   (1 << 1)

Definition at line 65 of file ts_utils.h.

P_TSV_IS_TSQUERY

#define P_TSV_IS_TSQUERY   (1 << 1)

Definition at line 30 of file ts_utils.h.

P_TSV_IS_WEB

#define P_TSV_IS_WEB   (1 << 2)

Definition at line 31 of file ts_utils.h.

P_TSV_OPR_IS_DELIM

#define P_TSV_OPR_IS_DELIM   (1 << 0)

Definition at line 29 of file ts_utils.h.

PG_GETARG_TSQUERYSIGN

#define PG_GETARG_TSQUERYSIGN

(

n

)

DatumGetTSQuerySign(PG_GETARG_DATUM(n))

Definition at line 266 of file ts_utils.h.

PG_RETURN_TSQUERYSIGN

#define PG_RETURN_TSQUERYSIGN

(

X

)

return TSQuerySignGetDatum(X)

Definition at line 265 of file ts_utils.h.

QTN_NEEDFREE

#define QTN_NEEDFREE   0x01

Definition at line 245 of file ts_utils.h.

QTN_NOCHANGE

#define QTN_NOCHANGE   0x02

Definition at line 246 of file ts_utils.h.

QTN_WORDFREE

#define QTN_WORDFREE   0x04

Definition at line 247 of file ts_utils.h.

TS_EXEC_EMPTY

#define TS_EXEC_EMPTY   (0x00)

Definition at line 188 of file ts_utils.h.

TS_EXEC_PHRASE_NO_POS

#define TS_EXEC_PHRASE_NO_POS   (0x02)

Definition at line 202 of file ts_utils.h.

TS_EXEC_SKIP_NOT

#define TS_EXEC_SKIP_NOT   (0x01)

Definition at line 195 of file ts_utils.h.

TSearchStrategyNumber

#define TSearchStrategyNumber   1

Definition at line 225 of file ts_utils.h.

TSearchWithClassStrategyNumber

#define TSearchWithClassStrategyNumber   2

Definition at line 226 of file ts_utils.h.

TSQS_SIGLEN

#define TSQS_SIGLEN   (sizeof(TSQuerySign)*BITS_PER_BYTE)

Definition at line 251 of file ts_utils.h.

Typedef Documentation

ExecPhraseData

typedef struct ExecPhraseData ExecPhraseData

PushFunction

typedef void(* PushFunction) (Datum opaque, TSQueryParserState state, char *token, int tokenlen, int16 tokenweights, bool prefix)

Definition at line 57 of file ts_utils.h.

QTNode

typedef struct QTNode QTNode

TSExecuteCallback

typedef TSTernaryValue(* TSExecuteCallback) (void *arg, QueryOperand *val, ExecPhraseData *data)

Definition at line 182 of file ts_utils.h.

TSQueryParserState

typedef struct TSQueryParserStateData* TSQueryParserState

Definition at line 55 of file ts_utils.h.

TSQuerySign

typedef uint64 TSQuerySign

Definition at line 249 of file ts_utils.h.

TSVectorParseState

typedef struct TSVectorParseStateData* TSVectorParseState

Definition at line 26 of file ts_utils.h.

Enumeration Type Documentation

TSTernaryValue

enum TSTernaryValue

Enumerator
TS_NO
TS_YES
TS_MAYBE

Definition at line 132 of file ts_utils.h.

{
    TS_NO,                      /* definitely no match */
    TS_YES,                     /* definitely does match */
    TS_MAYBE,                   /* can't verify match for lack of pos data */
} TSTernaryValue;

Function Documentation

clean_NOT()

QueryItem* clean_NOT	(	QueryItem *	ptr,
		int32 *	len
	)

cleanup_tsquery_stopwords()

TSQuery cleanup_tsquery_stopwords	(	TSQuery	in,
		bool	noisy
	)

Definition at line 387 of file tsquery_cleanup.c.

{
    int32       len,
                lenstr,
                commonlen,
                i;
    NODE       *root;
    int         ladd,
                radd;
    TSQuery     out;
    QueryItem  *items;
    char       *operands;
 
    if (in->size == 0)
        return in;
 
    /* eliminate stop words */
    root = clean_stopword_intree(maketree(GETQUERY(in)), &ladd, &radd);
    if (root == NULL)
    {
        if (noisy)
            ereport(NOTICE,
                    (errmsg("text-search query contains only stop words or doesn't contain lexemes, ignored")));
        out = palloc(HDRSIZETQ);
        out->size = 0;
        SET_VARSIZE(out, HDRSIZETQ);
        return out;
    }
 
    /*
     * Build TSQuery from plain view
     */
 
    lenstr = calcstrlen(root);
    items = plaintree(root, &len);
    commonlen = COMPUTESIZE(len, lenstr);
 
    out = palloc(commonlen);
    SET_VARSIZE(out, commonlen);
    out->size = len;
 
    memcpy(GETQUERY(out), items, len * sizeof(QueryItem));
 
    items = GETQUERY(out);
    operands = GETOPERAND(out);
    for (i = 0; i < out->size; i++)
    {
        QueryOperand *op = (QueryOperand *) &items[i];
 
        if (op->type != QI_VAL)
            continue;
 
        memcpy(operands, GETOPERAND(in) + op->distance, op->length);
        operands[op->length] = '\0';
        op->distance = operands - GETOPERAND(out);
        operands += op->length + 1;
    }
 
    return out;
}

References calcstrlen(), clean_stopword_intree(), COMPUTESIZE, QueryOperand::distance, ereport, errmsg(), GETOPERAND, GETQUERY, HDRSIZETQ, i, items, len, QueryOperand::length, maketree(), NOTICE, palloc(), plaintree(), QI_VAL, root, SET_VARSIZE, TSQueryData::size, and QueryOperand::type.

Referenced by parse_tsquery().

close_tsvector_parser()

void close_tsvector_parser

(

TSVectorParseState

state

)

Definition at line 90 of file tsvector_parser.c.

{
    pfree(state->word);
    pfree(state);
}

References pfree().

Referenced by parse_tsquery(), and tsvectorin().

DatumGetTSQuerySign()

static TSQuerySign DatumGetTSQuerySign ( Datum  X )

inlinestatic

Definition at line 260 of file ts_utils.h.

{
    return (TSQuerySign) DatumGetInt64(X);
}

References DatumGetInt64().

Referenced by gtsquery_consistent(), and gtsquery_penalty().

findsubquery()

QTNode* findsubquery	(	QTNode *	root,
		QTNode *	ex,
		QTNode *	subs,
		bool *	isfind
	)

Definition at line 267 of file tsquery_rewrite.c.

{
    bool        DidFind = false;
 
    root = dofindsubquery(root, ex, subs, &DidFind);
 
    if (isfind)
        *isfind = DidFind;
 
    return root;
}

References dofindsubquery(), and root.

Referenced by tsquery_rewrite(), and tsquery_rewrite_query().

generateHeadline()

text* generateHeadline

(

HeadlineParsedText *

prs

)

Definition at line 607 of file ts_parse.c.

{
    text       *out;
    char       *ptr;
    int         len = 128;
    int         numfragments = 0;
    int16       infrag = 0;
 
    HeadlineWordEntry *wrd = prs->words;
 
    out = (text *) palloc(len);
    ptr = ((char *) out) + VARHDRSZ;
 
    while (wrd - prs->words < prs->curwords)
    {
        while (wrd->len + prs->stopsellen + prs->startsellen + prs->fragdelimlen + (ptr - ((char *) out)) >= len)
        {
            int         dist = ptr - ((char *) out);
 
            len *= 2;
            out = (text *) repalloc(out, len);
            ptr = ((char *) out) + dist;
        }
 
        if (wrd->in && !wrd->repeated)
        {
            if (!infrag)
            {
 
                /* start of a new fragment */
                infrag = 1;
                numfragments++;
                /* add a fragment delimiter if this is after the first one */
                if (numfragments > 1)
                {
                    memcpy(ptr, prs->fragdelim, prs->fragdelimlen);
                    ptr += prs->fragdelimlen;
                }
            }
            if (wrd->replace)
            {
                *ptr = ' ';
                ptr++;
            }
            else if (!wrd->skip)
            {
                if (wrd->selected)
                {
                    memcpy(ptr, prs->startsel, prs->startsellen);
                    ptr += prs->startsellen;
                }
                memcpy(ptr, wrd->word, wrd->len);
                ptr += wrd->len;
                if (wrd->selected)
                {
                    memcpy(ptr, prs->stopsel, prs->stopsellen);
                    ptr += prs->stopsellen;
                }
            }
        }
        else if (!wrd->repeated)
        {
            if (infrag)
                infrag = 0;
            pfree(wrd->word);
        }
 
        wrd++;
    }
 
    SET_VARSIZE(out, ptr - ((char *) out));
    return out;
}

References HeadlineParsedText::curwords, HeadlineParsedText::fragdelim, HeadlineParsedText::fragdelimlen, HeadlineWordEntry::in, HeadlineWordEntry::len, len, palloc(), pfree(), repalloc(), HeadlineWordEntry::repeated, HeadlineWordEntry::replace, HeadlineWordEntry::selected, SET_VARSIZE, HeadlineWordEntry::skip, HeadlineParsedText::startsel, HeadlineParsedText::startsellen, HeadlineParsedText::stopsel, HeadlineParsedText::stopsellen, VARHDRSZ, HeadlineWordEntry::word, and HeadlineParsedText::words.

Referenced by headline_json_value(), and ts_headline_byid_opt().

gettoken_tsvector()

bool gettoken_tsvector	(	TSVectorParseState	state,
		char **	strval,
		int *	lenval,
		WordEntryPos **	pos_ptr,
		int *	poslen,
		char **	endptr
	)

Definition at line 176 of file tsvector_parser.c.

{
    int         oldstate = 0;
    char       *curpos = state->word;
    int         statecode = WAITWORD;
 
    /*
     * pos is for collecting the comma delimited list of positions followed by
     * the actual token.
     */
    WordEntryPos *pos = NULL;
    int         npos = 0;       /* elements of pos used */
    int         posalen = 0;    /* allocated size of pos */
 
    while (1)
    {
        if (statecode == WAITWORD)
        {
            if (*(state->prsbuf) == '\0')
                return false;
            else if (!state->is_web && t_iseq(state->prsbuf, '\''))
                statecode = WAITENDCMPLX;
            else if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDWORD;
            }
            else if ((state->oprisdelim && ISOPERATOR(state->prsbuf)) ||
                     (state->is_web && t_iseq(state->prsbuf, '"')))
                PRSSYNTAXERROR;
            else if (!t_isspace(state->prsbuf))
            {
                COPYCHAR(curpos, state->prsbuf);
                curpos += pg_mblen(state->prsbuf);
                statecode = WAITENDWORD;
            }
        }
        else if (statecode == WAITNEXTCHAR)
        {
            if (*(state->prsbuf) == '\0')
                ereturn(state->escontext, false,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("there is no escaped character: \"%s\"",
                                state->bufstart)));
            else
            {
                RESIZEPRSBUF;
                COPYCHAR(curpos, state->prsbuf);
                curpos += pg_mblen(state->prsbuf);
                Assert(oldstate != 0);
                statecode = oldstate;
            }
        }
        else if (statecode == WAITENDWORD)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDWORD;
            }
            else if (t_isspace(state->prsbuf) || *(state->prsbuf) == '\0' ||
                     (state->oprisdelim && ISOPERATOR(state->prsbuf)) ||
                     (state->is_web && t_iseq(state->prsbuf, '"')))
            {
                RESIZEPRSBUF;
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                *(curpos) = '\0';
                RETURN_TOKEN;
            }
            else if (t_iseq(state->prsbuf, ':'))
            {
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                *(curpos) = '\0';
                if (state->oprisdelim)
                    RETURN_TOKEN;
                else
                    statecode = INPOSINFO;
            }
            else
            {
                RESIZEPRSBUF;
                COPYCHAR(curpos, state->prsbuf);
                curpos += pg_mblen(state->prsbuf);
            }
        }
        else if (statecode == WAITENDCMPLX)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\''))
            {
                statecode = WAITCHARCMPLX;
            }
            else if (!state->is_web && t_iseq(state->prsbuf, '\\'))
            {
                statecode = WAITNEXTCHAR;
                oldstate = WAITENDCMPLX;
            }
            else if (*(state->prsbuf) == '\0')
                PRSSYNTAXERROR;
            else
            {
                RESIZEPRSBUF;
                COPYCHAR(curpos, state->prsbuf);
                curpos += pg_mblen(state->prsbuf);
            }
        }
        else if (statecode == WAITCHARCMPLX)
        {
            if (!state->is_web && t_iseq(state->prsbuf, '\''))
            {
                RESIZEPRSBUF;
                COPYCHAR(curpos, state->prsbuf);
                curpos += pg_mblen(state->prsbuf);
                statecode = WAITENDCMPLX;
            }
            else
            {
                RESIZEPRSBUF;
                *(curpos) = '\0';
                if (curpos == state->word)
                    PRSSYNTAXERROR;
                if (state->oprisdelim)
                {
                    /* state->prsbuf+=pg_mblen(state->prsbuf); */
                    RETURN_TOKEN;
                }
                else
                    statecode = WAITPOSINFO;
                continue;       /* recheck current character */
            }
        }
        else if (statecode == WAITPOSINFO)
        {
            if (t_iseq(state->prsbuf, ':'))
                statecode = INPOSINFO;
            else
                RETURN_TOKEN;
        }
        else if (statecode == INPOSINFO)
        {
            if (t_isdigit(state->prsbuf))
            {
                if (posalen == 0)
                {
                    posalen = 4;
                    pos = (WordEntryPos *) palloc(sizeof(WordEntryPos) * posalen);
                    npos = 0;
                }
                else if (npos + 1 >= posalen)
                {
                    posalen *= 2;
                    pos = (WordEntryPos *) repalloc(pos, sizeof(WordEntryPos) * posalen);
                }
                npos++;
                WEP_SETPOS(pos[npos - 1], LIMITPOS(atoi(state->prsbuf)));
                /* we cannot get here in tsquery, so no need for 2 errmsgs */
                if (WEP_GETPOS(pos[npos - 1]) == 0)
                    ereturn(state->escontext, false,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("wrong position info in tsvector: \"%s\"",
                                    state->bufstart)));
                WEP_SETWEIGHT(pos[npos - 1], 0);
                statecode = WAITPOSDELIM;
            }
            else
                PRSSYNTAXERROR;
        }
        else if (statecode == WAITPOSDELIM)
        {
            if (t_iseq(state->prsbuf, ','))
                statecode = INPOSINFO;
            else if (t_iseq(state->prsbuf, 'a') || t_iseq(state->prsbuf, 'A') || t_iseq(state->prsbuf, '*'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 3);
            }
            else if (t_iseq(state->prsbuf, 'b') || t_iseq(state->prsbuf, 'B'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 2);
            }
            else if (t_iseq(state->prsbuf, 'c') || t_iseq(state->prsbuf, 'C'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 1);
            }
            else if (t_iseq(state->prsbuf, 'd') || t_iseq(state->prsbuf, 'D'))
            {
                if (WEP_GETWEIGHT(pos[npos - 1]))
                    PRSSYNTAXERROR;
                WEP_SETWEIGHT(pos[npos - 1], 0);
            }
            else if (t_isspace(state->prsbuf) ||
                     *(state->prsbuf) == '\0')
                RETURN_TOKEN;
            else if (!t_isdigit(state->prsbuf))
                PRSSYNTAXERROR;
        }
        else                    /* internal error */
            elog(ERROR, "unrecognized state in gettoken_tsvector: %d",
                 statecode);
 
        /* get next char */
        state->prsbuf += pg_mblen(state->prsbuf);
    }
}

References Assert, COPYCHAR, elog, ereturn, errcode(), errmsg(), ERROR, INPOSINFO, ISOPERATOR, LIMITPOS, palloc(), pg_mblen(), PRSSYNTAXERROR, repalloc(), RESIZEPRSBUF, RETURN_TOKEN, t_isdigit(), t_iseq, t_isspace(), WAITCHARCMPLX, WAITENDCMPLX, WAITENDWORD, WAITNEXTCHAR, WAITPOSDELIM, WAITPOSINFO, WAITWORD, WEP_GETPOS, WEP_GETWEIGHT, WEP_SETPOS, and WEP_SETWEIGHT.

Referenced by gettoken_query_standard(), gettoken_query_websearch(), and tsvectorin().

hlparsetext()

void hlparsetext	(	Oid	cfgId,
		HeadlineParsedText *	prs,
		TSQuery	query,
		char *	buf,
		int32	buflen
	)

init_tsvector_parser()

TSVectorParseState init_tsvector_parser	(	char *	input,
		int	flags,
		Node *	escontext
	)

Definition at line 57 of file tsvector_parser.c.

{
    TSVectorParseState state;
 
    state = (TSVectorParseState) palloc(sizeof(struct TSVectorParseStateData));
    state->prsbuf = input;
    state->bufstart = input;
    state->len = 32;
    state->word = (char *) palloc(state->len);
    state->eml = pg_database_encoding_max_length();
    state->oprisdelim = (flags & P_TSV_OPR_IS_DELIM) != 0;
    state->is_tsquery = (flags & P_TSV_IS_TSQUERY) != 0;
    state->is_web = (flags & P_TSV_IS_WEB) != 0;
    state->escontext = escontext;
 
    return state;
}

References input, P_TSV_IS_TSQUERY, P_TSV_IS_WEB, P_TSV_OPR_IS_DELIM, palloc(), and pg_database_encoding_max_length().

Referenced by parse_tsquery(), and tsvectorin().

make_tsvector()

TSVector make_tsvector

(

ParsedText *

prs

)

Definition at line 165 of file to_tsany.c.

{
    int         i,
                j,
                lenstr = 0,
                totallen;
    TSVector    in;
    WordEntry  *ptr;
    char       *str;
    int         stroff;
 
    /* Merge duplicate words */
    if (prs->curwords > 0)
        prs->curwords = uniqueWORD(prs->words, prs->curwords);
 
    /* Determine space needed */
    for (i = 0; i < prs->curwords; i++)
    {
        lenstr += prs->words[i].len;
        if (prs->words[i].alen)
        {
            lenstr = SHORTALIGN(lenstr);
            lenstr += sizeof(uint16) + prs->words[i].pos.apos[0] * sizeof(WordEntryPos);
        }
    }
 
    if (lenstr > MAXSTRPOS)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("string is too long for tsvector (%d bytes, max %d bytes)", lenstr, MAXSTRPOS)));
 
    totallen = CALCDATASIZE(prs->curwords, lenstr);
    in = (TSVector) palloc0(totallen);
    SET_VARSIZE(in, totallen);
    in->size = prs->curwords;
 
    ptr = ARRPTR(in);
    str = STRPTR(in);
    stroff = 0;
    for (i = 0; i < prs->curwords; i++)
    {
        ptr->len = prs->words[i].len;
        ptr->pos = stroff;
        memcpy(str + stroff, prs->words[i].word, prs->words[i].len);
        stroff += prs->words[i].len;
        pfree(prs->words[i].word);
        if (prs->words[i].alen)
        {
            int         k = prs->words[i].pos.apos[0];
            WordEntryPos *wptr;
 
            if (k > 0xFFFF)
                elog(ERROR, "positions array too long");
 
            ptr->haspos = 1;
            stroff = SHORTALIGN(stroff);
            *(uint16 *) (str + stroff) = (uint16) k;
            wptr = POSDATAPTR(in, ptr);
            for (j = 0; j < k; j++)
            {
                WEP_SETWEIGHT(wptr[j], 0);
                WEP_SETPOS(wptr[j], prs->words[i].pos.apos[j + 1]);
            }
            stroff += sizeof(uint16) + k * sizeof(WordEntryPos);
            pfree(prs->words[i].pos.apos);
        }
        else
            ptr->haspos = 0;
        ptr++;
    }
 
    if (prs->words)
        pfree(prs->words);
 
    return in;
}

References ParsedWord::alen, ARRPTR, CALCDATASIZE, ParsedText::curwords, elog, ereport, errcode(), errmsg(), ERROR, WordEntry::haspos, i, j, WordEntry::len, ParsedWord::len, MAXSTRPOS, palloc0(), pfree(), WordEntry::pos, ParsedWord::pos, POSDATAPTR, SET_VARSIZE, SHORTALIGN, TSVectorData::size, str, STRPTR, uniqueWORD(), WEP_SETPOS, WEP_SETWEIGHT, ParsedWord::word, and ParsedText::words.

Referenced by json_to_tsvector_worker(), jsonb_to_tsvector_worker(), to_tsvector_byid(), and tsvector_update_trigger().

makeTSQuerySign()

TSQuerySign makeTSQuerySign

(

TSQuery

a

)

Definition at line 250 of file tsquery_op.c.

{
    int         i;
    QueryItem  *ptr = GETQUERY(a);
    TSQuerySign sign = 0;
 
    for (i = 0; i < a->size; i++)
    {
        if (ptr->type == QI_VAL)
            sign |= ((TSQuerySign) 1) << (((unsigned int) ptr->qoperand.valcrc) % TSQS_SIGLEN);
        ptr++;
    }
 
    return sign;
}

References a, GETQUERY, i, QI_VAL, QueryItem::qoperand, sign, TSQS_SIGLEN, QueryItem::type, and QueryOperand::valcrc.

Referenced by gtsquery_compress(), and gtsquery_consistent().

parse_tsquery()

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

Definition at line 821 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().

parsetext()

void parsetext	(	Oid	cfgId,
		ParsedText *	prs,
		char *	buf,
		int32	buflen
	)

pushOperator()

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

Definition at line 535 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().

pushStop()

void pushStop

(

TSQueryParserState

state

)

Definition at line 620 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().

pushValue()

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

Definition at line 584 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().

QT2QTN()

QTNode* QT2QTN	(	QueryItem *	in,
		char *	operand
	)

Definition at line 25 of file tsquery_util.c.

{
    QTNode     *node = (QTNode *) palloc0(sizeof(QTNode));
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    node->valnode = in;
 
    if (in->type == QI_OPR)
    {
        node->child = (QTNode **) palloc0(sizeof(QTNode *) * 2);
        node->child[0] = QT2QTN(in + 1, operand);
        node->sign = node->child[0]->sign;
        if (in->qoperator.oper == OP_NOT)
            node->nchild = 1;
        else
        {
            node->nchild = 2;
            node->child[1] = QT2QTN(in + in->qoperator.left, operand);
            node->sign |= node->child[1]->sign;
        }
    }
    else if (operand)
    {
        node->word = operand + in->qoperand.distance;
        node->sign = ((uint32) 1) << (((unsigned int) in->qoperand.valcrc) % 32);
    }
 
    return node;
}

References check_stack_depth(), QTNode::child, QueryOperand::distance, QueryOperator::left, QTNode::nchild, OP_NOT, QueryOperator::oper, palloc0(), QI_OPR, QueryItem::qoperand, QueryItem::qoperator, QTNode::sign, QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), join_tsqueries(), tsquery_not(), tsquery_rewrite(), and tsquery_rewrite_query().

QTN2QT()

TSQuery QTN2QT

(

QTNode *

in

)

Definition at line 363 of file tsquery_util.c.

{
    TSQuery     out;
    int         len;
    int         sumlen = 0,
                nnode = 0;
    QTN2QTState state;
 
    cntsize(in, &sumlen, &nnode);
 
    if (TSQUERY_TOO_BIG(nnode, sumlen))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("tsquery is too large")));
    len = COMPUTESIZE(nnode, sumlen);
 
    out = (TSQuery) palloc0(len);
    SET_VARSIZE(out, len);
    out->size = nnode;
 
    state.curitem = GETQUERY(out);
    state.operand = state.curoperand = GETOPERAND(out);
 
    fillQT(&state, in);
    return out;
}

References cntsize(), COMPUTESIZE, ereport, errcode(), errmsg(), ERROR, fillQT(), GETOPERAND, GETQUERY, len, palloc0(), SET_VARSIZE, TSQueryData::size, and TSQUERY_TOO_BIG.

Referenced by tsquery_and(), tsquery_not(), tsquery_or(), tsquery_phrase_distance(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNBinary()

void QTNBinary

(

QTNode *

in

)

Definition at line 250 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNBinary(in->child[i]);
 
    while (in->nchild > 2)
    {
        QTNode     *nn = (QTNode *) palloc0(sizeof(QTNode));
 
        nn->valnode = (QueryItem *) palloc0(sizeof(QueryItem));
        nn->child = (QTNode **) palloc0(sizeof(QTNode *) * 2);
 
        nn->nchild = 2;
        nn->flags = QTN_NEEDFREE;
 
        nn->child[0] = in->child[0];
        nn->child[1] = in->child[1];
        nn->sign = nn->child[0]->sign | nn->child[1]->sign;
 
        nn->valnode->type = in->valnode->type;
        nn->valnode->qoperator.oper = in->valnode->qoperator.oper;
 
        in->child[0] = nn;
        in->child[1] = in->child[in->nchild - 1];
        in->nchild--;
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, QueryOperator::oper, palloc0(), QI_OPR, QueryItem::qoperator, QTN_NEEDFREE, QTNode::sign, QueryItem::type, and QTNode::valnode.

Referenced by tsquery_rewrite(), and tsquery_rewrite_query().

QTNClearFlags()

void QTNClearFlags	(	QTNode *	in,
		uint32	flags
	)

Definition at line 434 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    in->flags &= ~flags;
 
    if (in->valnode->type != QI_VAL)
    {
        int         i;
 
        for (i = 0; i < in->nchild; i++)
            QTNClearFlags(in->child[i], flags);
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, QI_VAL, QueryItem::type, and QTNode::valnode.

Referenced by tsquery_rewrite_query().

QTNCopy()

QTNode* QTNCopy

(

QTNode *

in

)

Definition at line 396 of file tsquery_util.c.

{
    QTNode     *out;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    out = (QTNode *) palloc(sizeof(QTNode));
 
    *out = *in;
    out->valnode = (QueryItem *) palloc(sizeof(QueryItem));
    *(out->valnode) = *(in->valnode);
    out->flags |= QTN_NEEDFREE;
 
    if (in->valnode->type == QI_VAL)
    {
        out->word = palloc(in->valnode->qoperand.length + 1);
        memcpy(out->word, in->word, in->valnode->qoperand.length);
        out->word[in->valnode->qoperand.length] = '\0';
        out->flags |= QTN_WORDFREE;
    }
    else
    {
        int         i;
 
        out->child = (QTNode **) palloc(sizeof(QTNode *) * in->nchild);
 
        for (i = 0; i < in->nchild; i++)
            out->child[i] = QTNCopy(in->child[i]);
    }
 
    return out;
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QueryOperand::length, QTNode::nchild, palloc(), QI_VAL, QueryItem::qoperand, QTN_NEEDFREE, QTN_WORDFREE, QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by findeq().

QTNEq()

bool QTNEq	(	QTNode *	a,
		QTNode *	b
	)

Definition at line 183 of file tsquery_util.c.

{
    uint32      sign = a->sign & b->sign;
 
    if (!(sign == a->sign && sign == b->sign))
        return false;
 
    return (QTNodeCompare(a, b) == 0);
}

References a, b, QTNodeCompare(), and sign.

Referenced by findeq().

QTNFree()

void QTNFree

(

QTNode *

in

)

Definition at line 64 of file tsquery_util.c.

{
    if (!in)
        return;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type == QI_VAL && in->word && (in->flags & QTN_WORDFREE) != 0)
        pfree(in->word);
 
    if (in->valnode->type == QI_OPR)
    {
        int         i;
 
        for (i = 0; i < in->nchild; i++)
            QTNFree(in->child[i]);
    }
    if (in->child)
        pfree(in->child);
 
    if (in->flags & QTN_NEEDFREE)
        pfree(in->valnode);
 
    pfree(in);
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, pfree(), QI_OPR, QI_VAL, QTN_NEEDFREE, QTN_WORDFREE, QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), dofindsubquery(), findeq(), tsquery_and(), tsquery_not(), tsquery_or(), tsquery_phrase_distance(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNodeCompare()

int QTNodeCompare	(	QTNode *	an,
		QTNode *	bn
	)

Definition at line 97 of file tsquery_util.c.

{
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (an->valnode->type != bn->valnode->type)
        return (an->valnode->type > bn->valnode->type) ? -1 : 1;
 
    if (an->valnode->type == QI_OPR)
    {
        QueryOperator *ao = &an->valnode->qoperator;
        QueryOperator *bo = &bn->valnode->qoperator;
 
        if (ao->oper != bo->oper)
            return (ao->oper > bo->oper) ? -1 : 1;
 
        if (an->nchild != bn->nchild)
            return (an->nchild > bn->nchild) ? -1 : 1;
 
        {
            int         i,
                        res;
 
            for (i = 0; i < an->nchild; i++)
                if ((res = QTNodeCompare(an->child[i], bn->child[i])) != 0)
                    return res;
        }
 
        if (ao->oper == OP_PHRASE && ao->distance != bo->distance)
            return (ao->distance > bo->distance) ? -1 : 1;
 
        return 0;
    }
    else if (an->valnode->type == QI_VAL)
    {
        QueryOperand *ao = &an->valnode->qoperand;
        QueryOperand *bo = &bn->valnode->qoperand;
 
        if (ao->valcrc != bo->valcrc)
        {
            return (ao->valcrc > bo->valcrc) ? -1 : 1;
        }
 
        return tsCompareString(an->word, ao->length, bn->word, bo->length, false);
    }
    else
    {
        elog(ERROR, "unrecognized QueryItem type: %d", an->valnode->type);
        return 0;               /* keep compiler quiet */
    }
}

References check_stack_depth(), QTNode::child, QueryOperator::distance, elog, ERROR, i, QueryOperand::length, QTNode::nchild, OP_PHRASE, QueryOperator::oper, QI_OPR, QI_VAL, QueryItem::qoperand, QueryItem::qoperator, res, tsCompareString(), QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

Referenced by cmpQTN(), CompareTSQ(), findeq(), and QTNEq().

QTNSort()

void QTNSort

(

QTNode *

in

)

Definition at line 163 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNSort(in->child[i]);
    if (in->nchild > 1 && in->valnode->qoperator.oper != OP_PHRASE)
        qsort(in->child, in->nchild, sizeof(QTNode *), cmpQTN);
}

References check_stack_depth(), QTNode::child, cmpQTN(), i, QTNode::nchild, OP_PHRASE, QueryOperator::oper, QI_OPR, QueryItem::qoperator, qsort, QueryItem::type, and QTNode::valnode.

Referenced by findeq(), tsquery_rewrite(), and tsquery_rewrite_query().

QTNTernary()

void QTNTernary

(

QTNode *

in

)

Definition at line 201 of file tsquery_util.c.

{
    int         i;
 
    /* since this function recurses, it could be driven to stack overflow. */
    check_stack_depth();
 
    if (in->valnode->type != QI_OPR)
        return;
 
    for (i = 0; i < in->nchild; i++)
        QTNTernary(in->child[i]);
 
    /* Only AND and OR are associative, so don't flatten other node types */
    if (in->valnode->qoperator.oper != OP_AND &&
        in->valnode->qoperator.oper != OP_OR)
        return;
 
    for (i = 0; i < in->nchild; i++)
    {
        QTNode     *cc = in->child[i];
 
        if (cc->valnode->type == QI_OPR &&
            in->valnode->qoperator.oper == cc->valnode->qoperator.oper)
        {
            int         oldnchild = in->nchild;
 
            in->nchild += cc->nchild - 1;
            in->child = (QTNode **) repalloc(in->child, in->nchild * sizeof(QTNode *));
 
            if (i + 1 != oldnchild)
                memmove(in->child + i + cc->nchild, in->child + i + 1,
                        (oldnchild - i - 1) * sizeof(QTNode *));
 
            memcpy(in->child + i, cc->child, cc->nchild * sizeof(QTNode *));
            i += cc->nchild - 1;
 
            if (cc->flags & QTN_NEEDFREE)
                pfree(cc->valnode);
            pfree(cc);
        }
    }
}

References check_stack_depth(), QTNode::child, QTNode::flags, i, QTNode::nchild, OP_AND, OP_OR, QueryOperator::oper, pfree(), QI_OPR, QueryItem::qoperator, QTN_NEEDFREE, repalloc(), QueryItem::type, and QTNode::valnode.

Referenced by tsquery_rewrite(), and tsquery_rewrite_query().

reset_tsvector_parser()

void reset_tsvector_parser	(	TSVectorParseState	state,
		char *	input
	)

Definition at line 81 of file tsvector_parser.c.

{
    state->prsbuf = input;
}

References input.

Referenced by gettoken_query_standard(), and gettoken_query_websearch().

TS_execute()

bool TS_execute	(	QueryItem *	curitem,
		void *	arg,
		uint32	flags,
		TSExecuteCallback	chkcond
	)

Definition at line 1854 of file tsvector_op.c.

{
    /*
     * If we get TS_MAYBE from the recursion, return true.  We could only see
     * that result if the caller passed TS_EXEC_PHRASE_NO_POS, so there's no
     * need to check again.
     */
    return TS_execute_recurse(curitem, arg, flags, chkcond) != TS_NO;
}

References arg, TS_execute_recurse(), and TS_NO.

Referenced by Cover(), gtsvector_consistent(), hlCover(), and ts_match_vq().

TS_execute_locations()

List* TS_execute_locations	(	QueryItem *	curitem,
		void *	arg,
		uint32	flags,
		TSExecuteCallback	chkcond
	)

Definition at line 2007 of file tsvector_op.c.

{
    List       *result;
 
    /* No flags supported, as yet */
    Assert(flags == TS_EXEC_EMPTY);
    if (TS_execute_locations_recurse(curitem, arg, chkcond, &result))
        return result;
    return NIL;
}

References arg, Assert, NIL, TS_EXEC_EMPTY, and TS_execute_locations_recurse().

Referenced by prsd_headline().

TS_execute_ternary()

TSTernaryValue TS_execute_ternary	(	QueryItem *	curitem,
		void *	arg,
		uint32	flags,
		TSExecuteCallback	chkcond
	)

Definition at line 1871 of file tsvector_op.c.

{
    return TS_execute_recurse(curitem, arg, flags, chkcond);
}

References arg, and TS_execute_recurse().

Referenced by gin_tsquery_consistent(), and gin_tsquery_triconsistent().

tsCompareString()

int32 tsCompareString	(	char *	a,
		int	lena,
		char *	b,
		int	lenb,
		bool	prefix
	)

Definition at line 1152 of file tsvector_op.c.

{
    int         cmp;
 
    if (lena == 0)
    {
        if (prefix)
            cmp = 0;            /* empty string is prefix of anything */
        else
            cmp = (lenb > 0) ? -1 : 0;
    }
    else if (lenb == 0)
    {
        cmp = (lena > 0) ? 1 : 0;
    }
    else
    {
        cmp = memcmp(a, b, Min((unsigned int) lena, (unsigned int) lenb));
 
        if (prefix)
        {
            if (cmp == 0 && lena > lenb)
                cmp = 1;        /* a is longer, so not a prefix of b */
        }
        else if (cmp == 0 && lena != lenb)
        {
            cmp = (lena < lenb) ? -1 : 1;
        }
    }
 
    return cmp;
}

References a, b, cmp(), and Min.

Referenced by checkcondition_str(), compare_text_lexemes(), compareentry(), compareQueryOperand(), compareWORD(), gin_cmp_prefix(), gin_cmp_tslexeme(), hlfinditem(), QTNodeCompare(), silly_cmp_tsvector(), and tsvector_bsearch().

tsquery_requires_match()

bool tsquery_requires_match

(

QueryItem *

curitem

)

Definition at line 2156 of file tsvector_op.c.

{
    /* since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    if (curitem->type == QI_VAL)
        return true;
 
    switch (curitem->qoperator.oper)
    {
        case OP_NOT:
 
            /*
             * Assume there are no required matches underneath a NOT.  For
             * some cases with nested NOTs, we could prove there's a required
             * match, but it seems unlikely to be worth the trouble.
             */
            return false;
 
        case OP_PHRASE:
 
            /*
             * Treat OP_PHRASE as OP_AND here
             */
        case OP_AND:
            /* If either side requires a match, we're good */
            if (tsquery_requires_match(curitem + curitem->qoperator.left))
                return true;
            else
                return tsquery_requires_match(curitem + 1);
 
        case OP_OR:
            /* Both sides must require a match */
            if (tsquery_requires_match(curitem + curitem->qoperator.left))
                return tsquery_requires_match(curitem + 1);
            else
                return false;
 
        default:
            elog(ERROR, "unrecognized operator: %d", curitem->qoperator.oper);
    }
 
    /* not reachable, but keep compiler quiet */
    return false;
}

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

Referenced by gin_extract_tsquery().

TSQuerySignGetDatum()

static Datum TSQuerySignGetDatum ( TSQuerySign  X )

inlinestatic

Definition at line 254 of file ts_utils.h.

{
    return Int64GetDatum((int64) X);
}

References Int64GetDatum().

Referenced by gtsquery_compress(), and gtsquery_picksplit().