#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:

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;
}

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 (!isspace((unsigned char) *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 (isspace((unsigned char) *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 (isdigit((unsigned char) *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 (isspace((unsigned char) *state->prsbuf) ||
                     *(state->prsbuf) == '\0')
                RETURN_TOKEN;
            else if (!isdigit((unsigned char) *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_iseq, 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 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().

◆ parsetext()

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

◆ 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().

◆ 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().

◆ 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().

◆ 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, QT2QTN(), QTNode::sign, QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), join_tsqueries(), QT2QTN(), 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, QTNBinary(), QTNode::sign, QueryItem::type, and QTNode::valnode.

Referenced by QTNBinary(), 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, QTNClearFlags(), QueryItem::type, and QTNode::valnode.

Referenced by QTNClearFlags(), and 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, QTNCopy(), QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by findeq(), and QTNCopy().

◆ 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, QTNFree(), QueryItem::type, QTNode::valnode, and QTNode::word.

Referenced by CompareTSQ(), dofindsubquery(), findeq(), QTNFree(), 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, QTNodeCompare(), tsCompareString(), QueryItem::type, QueryOperand::valcrc, QTNode::valnode, and QTNode::word.

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

◆ 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, QTNSort(), QueryItem::type, and QTNode::valnode.

Referenced by findeq(), QTNSort(), 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, QTNTernary(), repalloc(), QueryItem::type, and QTNode::valnode.

Referenced by QTNTernary(), 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, tsquery_requires_match(), and QueryItem::type.

Referenced by gin_extract_tsquery(), and tsquery_requires_match().

◆ TSQuerySignGetDatum()

static Datum TSQuerySignGetDatum ( TSQuerySign X )