to_tsany.c File Reference

#include "postgres.h"
#include "tsearch/ts_cache.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
#include "utils/jsonfuncs.h"

Include dependency graph for to_tsany.c:

Go to the source code of this file.

Data Structures
struct	MorphOpaque
struct	TSVectorBuildState

Typedefs
typedef struct MorphOpaque	MorphOpaque
typedef struct TSVectorBuildState	TSVectorBuildState

Functions
static void	add_to_tsvector (void *_state, char *elem_value, int elem_len)
Datum	get_current_ts_config (PG_FUNCTION_ARGS)
static int	compareWORD (const void *a, const void *b)
static int	uniqueWORD (ParsedWord *a, int32 l)
TSVector	make_tsvector (ParsedText *prs)
Datum	to_tsvector_byid (PG_FUNCTION_ARGS)
Datum	to_tsvector (PG_FUNCTION_ARGS)
static TSVector	jsonb_to_tsvector_worker (Oid cfgId, Jsonb *jb, uint32 flags)
Datum	jsonb_string_to_tsvector_byid (PG_FUNCTION_ARGS)
Datum	jsonb_string_to_tsvector (PG_FUNCTION_ARGS)
Datum	jsonb_to_tsvector_byid (PG_FUNCTION_ARGS)
Datum	jsonb_to_tsvector (PG_FUNCTION_ARGS)
static TSVector	json_to_tsvector_worker (Oid cfgId, text *json, uint32 flags)
Datum	json_string_to_tsvector_byid (PG_FUNCTION_ARGS)
Datum	json_string_to_tsvector (PG_FUNCTION_ARGS)
Datum	json_to_tsvector_byid (PG_FUNCTION_ARGS)
Datum	json_to_tsvector (PG_FUNCTION_ARGS)
static void	pushval_morph (Datum opaque, TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
Datum	to_tsquery_byid (PG_FUNCTION_ARGS)
Datum	to_tsquery (PG_FUNCTION_ARGS)
Datum	plainto_tsquery_byid (PG_FUNCTION_ARGS)
Datum	plainto_tsquery (PG_FUNCTION_ARGS)
Datum	phraseto_tsquery_byid (PG_FUNCTION_ARGS)
Datum	phraseto_tsquery (PG_FUNCTION_ARGS)
Datum	websearch_to_tsquery_byid (PG_FUNCTION_ARGS)
Datum	websearch_to_tsquery (PG_FUNCTION_ARGS)

Typedef Documentation

MorphOpaque

typedef struct MorphOpaque MorphOpaque

TSVectorBuildState

typedef struct TSVectorBuildState TSVectorBuildState

Function Documentation

add_to_tsvector()

static void add_to_tsvector ( void *  _state, char *  elem_value, int  elem_len  )

static

Definition at line 443 of file to_tsany.c.

{
    TSVectorBuildState *state = (TSVectorBuildState *) _state;
    ParsedText *prs = state->prs;
    int32       prevwords;
 
    if (prs->words == NULL)
    {
        /*
         * First time through: initialize words array to a reasonable size.
         * (parsetext() will realloc it bigger as needed.)
         */
        prs->lenwords = 16;
        prs->words = (ParsedWord *) palloc(sizeof(ParsedWord) * prs->lenwords);
        prs->curwords = 0;
        prs->pos = 0;
    }
 
    prevwords = prs->curwords;
 
    parsetext(state->cfgId, prs, elem_value, elem_len);
 
    /*
     * If we extracted any words from this JSON element, advance pos to create
     * an artificial break between elements.  This is because we don't want
     * phrase searches to think that the last word in this element is adjacent
     * to the first word in the next one.
     */
    if (prs->curwords > prevwords)
        prs->pos += 1;
}

References ParsedText::curwords, ParsedText::lenwords, palloc(), parsetext(), ParsedText::pos, and ParsedText::words.

Referenced by json_to_tsvector_worker(), and jsonb_to_tsvector_worker().

compareWORD()

static int compareWORD ( const void *  a, const void *  b  )

static

Definition at line 57 of file to_tsany.c.

{
    int         res;
 
    res = tsCompareString(((const ParsedWord *) a)->word, ((const ParsedWord *) a)->len,
                          ((const ParsedWord *) b)->word, ((const ParsedWord *) b)->len,
                          false);
 
    if (res == 0)
    {
        if (((const ParsedWord *) a)->pos.pos == ((const ParsedWord *) b)->pos.pos)
            return 0;
 
        res = (((const ParsedWord *) a)->pos.pos > ((const ParsedWord *) b)->pos.pos) ? 1 : -1;
    }
 
    return res;
}

References a, b, len, tsCompareString(), and word().

Referenced by uniqueWORD().

get_current_ts_config()

Datum get_current_ts_config

(

PG_FUNCTION_ARGS

)

Definition at line 48 of file to_tsany.c.

{
    PG_RETURN_OID(getTSCurrentConfig(true));
}

References getTSCurrentConfig(), and PG_RETURN_OID.

json_string_to_tsvector()

Datum json_string_to_tsvector

(

PG_FUNCTION_ARGS

)

Definition at line 393 of file to_tsany.c.

{
    text       *json = PG_GETARG_TEXT_P(0);
    Oid         cfgId;
    TSVector    result;
 
    cfgId = getTSCurrentConfig(true);
    result = json_to_tsvector_worker(cfgId, json, jtiString);
    PG_FREE_IF_COPY(json, 0);
 
    PG_RETURN_TSVECTOR(result);
}

References getTSCurrentConfig(), json_to_tsvector_worker(), jtiString, PG_FREE_IF_COPY, PG_GETARG_TEXT_P, and PG_RETURN_TSVECTOR.

json_string_to_tsvector_byid()

Datum json_string_to_tsvector_byid

(

PG_FUNCTION_ARGS

)

Definition at line 380 of file to_tsany.c.

{
    Oid         cfgId = PG_GETARG_OID(0);
    text       *json = PG_GETARG_TEXT_P(1);
    TSVector    result;
 
    result = json_to_tsvector_worker(cfgId, json, jtiString);
    PG_FREE_IF_COPY(json, 1);
 
    PG_RETURN_TSVECTOR(result);
}

References json_to_tsvector_worker(), jtiString, PG_FREE_IF_COPY, PG_GETARG_OID, PG_GETARG_TEXT_P, and PG_RETURN_TSVECTOR.

json_to_tsvector()

Datum json_to_tsvector

(

PG_FUNCTION_ARGS

)

Definition at line 423 of file to_tsany.c.

{
    text       *json = PG_GETARG_TEXT_P(0);
    Jsonb      *jbFlags = PG_GETARG_JSONB_P(1);
    Oid         cfgId;
    TSVector    result;
    uint32      flags = parse_jsonb_index_flags(jbFlags);
 
    cfgId = getTSCurrentConfig(true);
    result = json_to_tsvector_worker(cfgId, json, flags);
    PG_FREE_IF_COPY(json, 0);
    PG_FREE_IF_COPY(jbFlags, 1);
 
    PG_RETURN_TSVECTOR(result);
}

References getTSCurrentConfig(), json_to_tsvector_worker(), parse_jsonb_index_flags(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_GETARG_TEXT_P, and PG_RETURN_TSVECTOR.

json_to_tsvector_byid()

Datum json_to_tsvector_byid

(

PG_FUNCTION_ARGS

)

Definition at line 407 of file to_tsany.c.

{
    Oid         cfgId = PG_GETARG_OID(0);
    text       *json = PG_GETARG_TEXT_P(1);
    Jsonb      *jbFlags = PG_GETARG_JSONB_P(2);
    TSVector    result;
    uint32      flags = parse_jsonb_index_flags(jbFlags);
 
    result = json_to_tsvector_worker(cfgId, json, flags);
    PG_FREE_IF_COPY(json, 1);
    PG_FREE_IF_COPY(jbFlags, 2);
 
    PG_RETURN_TSVECTOR(result);
}

References json_to_tsvector_worker(), parse_jsonb_index_flags(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_GETARG_OID, PG_GETARG_TEXT_P, and PG_RETURN_TSVECTOR.

json_to_tsvector_worker()

static TSVector json_to_tsvector_worker ( Oid  cfgId, text *  json, uint32  flags  )

static

Definition at line 364 of file to_tsany.c.

{
    TSVectorBuildState state;
    ParsedText  prs;
 
    prs.words = NULL;
    prs.curwords = 0;
    state.prs = &prs;
    state.cfgId = cfgId;
 
    iterate_json_values(json, flags, &state, add_to_tsvector);
 
    return make_tsvector(&prs);
}

References add_to_tsvector(), ParsedText::curwords, iterate_json_values(), make_tsvector(), and ParsedText::words.

Referenced by json_string_to_tsvector(), json_string_to_tsvector_byid(), json_to_tsvector(), and json_to_tsvector_byid().

jsonb_string_to_tsvector()

Datum jsonb_string_to_tsvector

(

PG_FUNCTION_ARGS

)

Definition at line 314 of file to_tsany.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    Oid         cfgId;
    TSVector    result;
 
    cfgId = getTSCurrentConfig(true);
    result = jsonb_to_tsvector_worker(cfgId, jb, jtiString);
    PG_FREE_IF_COPY(jb, 0);
 
    PG_RETURN_TSVECTOR(result);
}

References getTSCurrentConfig(), jsonb_to_tsvector_worker(), jtiString, PG_FREE_IF_COPY, PG_GETARG_JSONB_P, and PG_RETURN_TSVECTOR.

jsonb_string_to_tsvector_byid()

Datum jsonb_string_to_tsvector_byid

(

PG_FUNCTION_ARGS

)

Definition at line 301 of file to_tsany.c.

{
    Oid         cfgId = PG_GETARG_OID(0);
    Jsonb      *jb = PG_GETARG_JSONB_P(1);
    TSVector    result;
 
    result = jsonb_to_tsvector_worker(cfgId, jb, jtiString);
    PG_FREE_IF_COPY(jb, 1);
 
    PG_RETURN_TSVECTOR(result);
}

References jsonb_to_tsvector_worker(), jtiString, PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_GETARG_OID, and PG_RETURN_TSVECTOR.

jsonb_to_tsvector()

Datum jsonb_to_tsvector

(

PG_FUNCTION_ARGS

)

Definition at line 344 of file to_tsany.c.

{
    Jsonb      *jb = PG_GETARG_JSONB_P(0);
    Jsonb      *jbFlags = PG_GETARG_JSONB_P(1);
    Oid         cfgId;
    TSVector    result;
    uint32      flags = parse_jsonb_index_flags(jbFlags);
 
    cfgId = getTSCurrentConfig(true);
    result = jsonb_to_tsvector_worker(cfgId, jb, flags);
    PG_FREE_IF_COPY(jb, 0);
    PG_FREE_IF_COPY(jbFlags, 1);
 
    PG_RETURN_TSVECTOR(result);
}

References getTSCurrentConfig(), jsonb_to_tsvector_worker(), parse_jsonb_index_flags(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, and PG_RETURN_TSVECTOR.

jsonb_to_tsvector_byid()

Datum jsonb_to_tsvector_byid

(

PG_FUNCTION_ARGS

)

Definition at line 328 of file to_tsany.c.

{
    Oid         cfgId = PG_GETARG_OID(0);
    Jsonb      *jb = PG_GETARG_JSONB_P(1);
    Jsonb      *jbFlags = PG_GETARG_JSONB_P(2);
    TSVector    result;
    uint32      flags = parse_jsonb_index_flags(jbFlags);
 
    result = jsonb_to_tsvector_worker(cfgId, jb, flags);
    PG_FREE_IF_COPY(jb, 1);
    PG_FREE_IF_COPY(jbFlags, 2);
 
    PG_RETURN_TSVECTOR(result);
}

References jsonb_to_tsvector_worker(), parse_jsonb_index_flags(), PG_FREE_IF_COPY, PG_GETARG_JSONB_P, PG_GETARG_OID, and PG_RETURN_TSVECTOR.

jsonb_to_tsvector_worker()

static TSVector jsonb_to_tsvector_worker ( Oid  cfgId, Jsonb *  jb, uint32  flags  )

static

Definition at line 285 of file to_tsany.c.

{
    TSVectorBuildState state;
    ParsedText  prs;
 
    prs.words = NULL;
    prs.curwords = 0;
    state.prs = &prs;
    state.cfgId = cfgId;
 
    iterate_jsonb_values(jb, flags, &state, add_to_tsvector);
 
    return make_tsvector(&prs);
}

References add_to_tsvector(), ParsedText::curwords, iterate_jsonb_values(), make_tsvector(), and ParsedText::words.

Referenced by jsonb_string_to_tsvector(), jsonb_string_to_tsvector_byid(), jsonb_to_tsvector(), and jsonb_to_tsvector_byid().

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

phraseto_tsquery()

Datum phraseto_tsquery

(

PG_FUNCTION_ARGS

)

Definition at line 680 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    Oid         cfgId;
 
    cfgId = getTSCurrentConfig(true);
    PG_RETURN_DATUM(DirectFunctionCall2(phraseto_tsquery_byid,
                                        ObjectIdGetDatum(cfgId),
                                        PointerGetDatum(in)));
}

References DirectFunctionCall2, getTSCurrentConfig(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_DATUM, phraseto_tsquery_byid(), and PointerGetDatum().

phraseto_tsquery_byid()

Datum phraseto_tsquery_byid

(

PG_FUNCTION_ARGS

)

Definition at line 655 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(1);
    TSQuery     query;
    MorphOpaque data;
 
    data.cfg_id = PG_GETARG_OID(0);
 
    /*
     * parse_tsquery() with P_TSQ_PLAIN flag takes the whole input text as a
     * single morph.  Passing OP_PHRASE as a qoperator makes tsquery require
     * matching of word positions.
     */
    data.qoperator = OP_PHRASE;
 
    query = parse_tsquery(text_to_cstring(in),
                          pushval_morph,
                          PointerGetDatum(&data),
                          P_TSQ_PLAIN,
                          NULL);
 
    PG_RETURN_TSQUERY(query);
}

References data, OP_PHRASE, P_TSQ_PLAIN, parse_tsquery(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_TSQUERY, PointerGetDatum(), pushval_morph(), and text_to_cstring().

Referenced by phraseto_tsquery().

plainto_tsquery()

Datum plainto_tsquery

(

PG_FUNCTION_ARGS

)

Definition at line 642 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    Oid         cfgId;
 
    cfgId = getTSCurrentConfig(true);
    PG_RETURN_DATUM(DirectFunctionCall2(plainto_tsquery_byid,
                                        ObjectIdGetDatum(cfgId),
                                        PointerGetDatum(in)));
}

References DirectFunctionCall2, getTSCurrentConfig(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_DATUM, plainto_tsquery_byid(), and PointerGetDatum().

Referenced by ts_match_tt().

plainto_tsquery_byid()

Datum plainto_tsquery_byid

(

PG_FUNCTION_ARGS

)

Definition at line 617 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(1);
    TSQuery     query;
    MorphOpaque data;
 
    data.cfg_id = PG_GETARG_OID(0);
 
    /*
     * parse_tsquery() with P_TSQ_PLAIN flag takes the whole input text as a
     * single morph.  Passing OP_PHRASE as a qoperator makes tsquery require
     * matching of all words independently on their positions.
     */
    data.qoperator = OP_AND;
 
    query = parse_tsquery(text_to_cstring(in),
                          pushval_morph,
                          PointerGetDatum(&data),
                          P_TSQ_PLAIN,
                          NULL);
 
    PG_RETURN_POINTER(query);
}

References data, OP_AND, P_TSQ_PLAIN, parse_tsquery(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_POINTER, PointerGetDatum(), pushval_morph(), and text_to_cstring().

Referenced by plainto_tsquery().

pushval_morph()

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

static

Definition at line 492 of file to_tsany.c.

{
    int32       count = 0;
    ParsedText  prs;
    uint32      variant,
                pos = 0,
                cntvar = 0,
                cntpos = 0,
                cnt = 0;
    MorphOpaque *data = (MorphOpaque *) DatumGetPointer(opaque);
 
    prs.lenwords = 4;
    prs.curwords = 0;
    prs.pos = 0;
    prs.words = (ParsedWord *) palloc(sizeof(ParsedWord) * prs.lenwords);
 
    parsetext(data->cfg_id, &prs, strval, lenval);
 
    if (prs.curwords > 0)
    {
        while (count < prs.curwords)
        {
            /*
             * Were any stop words removed? If so, fill empty positions with
             * placeholders linked by an appropriate operator.
             */
            if (pos > 0 && pos + 1 < prs.words[count].pos.pos)
            {
                while (pos + 1 < prs.words[count].pos.pos)
                {
                    /* put placeholders for each missing stop word */
                    pushStop(state);
                    if (cntpos)
                        pushOperator(state, data->qoperator, 1);
                    cntpos++;
                    pos++;
                }
            }
 
            /* save current word's position */
            pos = prs.words[count].pos.pos;
 
            /* Go through all variants obtained from this token */
            cntvar = 0;
            while (count < prs.curwords && pos == prs.words[count].pos.pos)
            {
                variant = prs.words[count].nvariant;
 
                /* Push all words belonging to the same variant */
                cnt = 0;
                while (count < prs.curwords &&
                       pos == prs.words[count].pos.pos &&
                       variant == prs.words[count].nvariant)
                {
                    pushValue(state,
                              prs.words[count].word,
                              prs.words[count].len,
                              weight,
                              ((prs.words[count].flags & TSL_PREFIX) || prefix));
                    pfree(prs.words[count].word);
                    if (cnt)
                        pushOperator(state, OP_AND, 0);
                    cnt++;
                    count++;
                }
 
                if (cntvar)
                    pushOperator(state, OP_OR, 0);
                cntvar++;
            }
 
            if (cntpos)
            {
                /* distance may be useful */
                pushOperator(state, data->qoperator, 1);
            }
 
            cntpos++;
        }
 
        pfree(prs.words);
    }
    else
        pushStop(state);
}

References ParsedText::curwords, data, DatumGetPointer(), ParsedWord::flags, ParsedWord::len, ParsedText::lenwords, ParsedWord::nvariant, OP_AND, OP_OR, palloc(), parsetext(), pfree(), ParsedWord::pos, ParsedText::pos, pushOperator(), pushStop(), pushValue(), TSL_PREFIX, ParsedWord::word, and ParsedText::words.

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

to_tsquery()

Datum to_tsquery

(

PG_FUNCTION_ARGS

)

Definition at line 605 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    Oid         cfgId;
 
    cfgId = getTSCurrentConfig(true);
    PG_RETURN_DATUM(DirectFunctionCall2(to_tsquery_byid,
                                        ObjectIdGetDatum(cfgId),
                                        PointerGetDatum(in)));
}

References DirectFunctionCall2, getTSCurrentConfig(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PointerGetDatum(), and to_tsquery_byid().

to_tsquery_byid()

Datum to_tsquery_byid

(

PG_FUNCTION_ARGS

)

Definition at line 579 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(1);
    TSQuery     query;
    MorphOpaque data;
 
    data.cfg_id = PG_GETARG_OID(0);
 
    /*
     * Passing OP_PHRASE as a qoperator makes tsquery require matching of word
     * positions of a complex morph exactly match the tsvector.  Also, when
     * the complex morphs are connected with OP_PHRASE operator, we connect
     * all their words into the OP_PHRASE sequence.
     */
    data.qoperator = OP_PHRASE;
 
    query = parse_tsquery(text_to_cstring(in),
                          pushval_morph,
                          PointerGetDatum(&data),
                          0,
                          NULL);
 
    PG_RETURN_TSQUERY(query);
}

References data, OP_PHRASE, parse_tsquery(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_TSQUERY, PointerGetDatum(), pushval_morph(), and text_to_cstring().

Referenced by to_tsquery().

to_tsvector()

Datum to_tsvector

(

PG_FUNCTION_ARGS

)

Definition at line 270 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    Oid         cfgId;
 
    cfgId = getTSCurrentConfig(true);
    PG_RETURN_DATUM(DirectFunctionCall2(to_tsvector_byid,
                                        ObjectIdGetDatum(cfgId),
                                        PointerGetDatum(in)));
}

References DirectFunctionCall2, getTSCurrentConfig(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PointerGetDatum(), and to_tsvector_byid().

Referenced by ts_match_tq(), and ts_match_tt().

to_tsvector_byid()

Datum to_tsvector_byid

(

PG_FUNCTION_ARGS

)

Definition at line 243 of file to_tsany.c.

{
    Oid         cfgId = PG_GETARG_OID(0);
    text       *in = PG_GETARG_TEXT_PP(1);
    ParsedText  prs;
    TSVector    out;
 
    prs.lenwords = VARSIZE_ANY_EXHDR(in) / 6;   /* just estimation of word's
                                                 * number */
    if (prs.lenwords < 2)
        prs.lenwords = 2;
    else if (prs.lenwords > MaxAllocSize / sizeof(ParsedWord))
        prs.lenwords = MaxAllocSize / sizeof(ParsedWord);
    prs.curwords = 0;
    prs.pos = 0;
    prs.words = (ParsedWord *) palloc(sizeof(ParsedWord) * prs.lenwords);
 
    parsetext(cfgId, &prs, VARDATA_ANY(in), VARSIZE_ANY_EXHDR(in));
 
    PG_FREE_IF_COPY(in, 1);
 
    out = make_tsvector(&prs);
 
    PG_RETURN_TSVECTOR(out);
}

References ParsedText::curwords, ParsedText::lenwords, make_tsvector(), MaxAllocSize, palloc(), parsetext(), PG_FREE_IF_COPY, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_TSVECTOR, ParsedText::pos, VARDATA_ANY, VARSIZE_ANY_EXHDR, and ParsedText::words.

Referenced by to_tsvector().

uniqueWORD()

static int uniqueWORD ( ParsedWord *  a, int32  l  )

static

Definition at line 77 of file to_tsany.c.

{
    ParsedWord *ptr,
               *res;
    int         tmppos;
 
    if (l == 1)
    {
        tmppos = LIMITPOS(a->pos.pos);
        a->alen = 2;
        a->pos.apos = (uint16 *) palloc(sizeof(uint16) * a->alen);
        a->pos.apos[0] = 1;
        a->pos.apos[1] = tmppos;
        return l;
    }
 
    res = a;
    ptr = a + 1;
 
    /*
     * Sort words with its positions
     */
    qsort(a, l, sizeof(ParsedWord), compareWORD);
 
    /*
     * Initialize first word and its first position
     */
    tmppos = LIMITPOS(a->pos.pos);
    a->alen = 2;
    a->pos.apos = (uint16 *) palloc(sizeof(uint16) * a->alen);
    a->pos.apos[0] = 1;
    a->pos.apos[1] = tmppos;
 
    /*
     * Summarize position information for each word
     */
    while (ptr - a < l)
    {
        if (!(ptr->len == res->len &&
              strncmp(ptr->word, res->word, res->len) == 0))
        {
            /*
             * Got a new word, so put it in result
             */
            res++;
            res->len = ptr->len;
            res->word = ptr->word;
            tmppos = LIMITPOS(ptr->pos.pos);
            res->alen = 2;
            res->pos.apos = (uint16 *) palloc(sizeof(uint16) * res->alen);
            res->pos.apos[0] = 1;
            res->pos.apos[1] = tmppos;
        }
        else
        {
            /*
             * The word already exists, so adjust position information. But
             * before we should check size of position's array, max allowed
             * value for position and uniqueness of position
             */
            pfree(ptr->word);
            if (res->pos.apos[0] < MAXNUMPOS - 1 && res->pos.apos[res->pos.apos[0]] != MAXENTRYPOS - 1 &&
                res->pos.apos[res->pos.apos[0]] != LIMITPOS(ptr->pos.pos))
            {
                if (res->pos.apos[0] + 1 >= res->alen)
                {
                    res->alen *= 2;
                    res->pos.apos = (uint16 *) repalloc(res->pos.apos, sizeof(uint16) * res->alen);
                }
                if (res->pos.apos[0] == 0 || res->pos.apos[res->pos.apos[0]] != LIMITPOS(ptr->pos.pos))
                {
                    res->pos.apos[res->pos.apos[0] + 1] = LIMITPOS(ptr->pos.pos);
                    res->pos.apos[0]++;
                }
            }
        }
        ptr++;
    }
 
    return res + 1 - a;
}

References a, ParsedWord::alen, compareWORD(), ParsedWord::len, LIMITPOS, MAXENTRYPOS, MAXNUMPOS, palloc(), pfree(), ParsedWord::pos, qsort, repalloc(), and ParsedWord::word.

Referenced by make_tsvector().

websearch_to_tsquery()

Datum websearch_to_tsquery

(

PG_FUNCTION_ARGS

)

Definition at line 718 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(0);
    Oid         cfgId;
 
    cfgId = getTSCurrentConfig(true);
    PG_RETURN_DATUM(DirectFunctionCall2(websearch_to_tsquery_byid,
                                        ObjectIdGetDatum(cfgId),
                                        PointerGetDatum(in)));
}

References DirectFunctionCall2, getTSCurrentConfig(), ObjectIdGetDatum(), PG_GETARG_TEXT_PP, PG_RETURN_DATUM, PointerGetDatum(), and websearch_to_tsquery_byid().

websearch_to_tsquery_byid()

Datum websearch_to_tsquery_byid

(

PG_FUNCTION_ARGS

)

Definition at line 692 of file to_tsany.c.

{
    text       *in = PG_GETARG_TEXT_PP(1);
    MorphOpaque data;
    TSQuery     query = NULL;
 
    data.cfg_id = PG_GETARG_OID(0);
 
    /*
     * Passing OP_PHRASE as a qoperator makes tsquery require matching of word
     * positions of a complex morph exactly match the tsvector.  Also, when
     * the complex morphs are given in quotes, we connect all their words into
     * the OP_PHRASE sequence.
     */
    data.qoperator = OP_PHRASE;
 
    query = parse_tsquery(text_to_cstring(in),
                          pushval_morph,
                          PointerGetDatum(&data),
                          P_TSQ_WEB,
                          NULL);
 
    PG_RETURN_TSQUERY(query);
}

References data, OP_PHRASE, P_TSQ_WEB, parse_tsquery(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_TSQUERY, PointerGetDatum(), pushval_morph(), and text_to_cstring().

Referenced by websearch_to_tsquery().