Quelle  to_tsany.c

/*-------------------------------------------------------------------------
 *
 * to_tsany.c
 *  to_ts* function definitions
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 *
 *
 * IDENTIFICATION
 *   src/backend/tsearch/to_tsany.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

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


/*
 * Opaque data structure, which is passed by parse_tsquery() to pushval_morph().
 */
typedef struct MorphOpaque
{
 Oid   cfg_id;

 /*
  * Single tsquery morph could be parsed into multiple words.  When these
  * words reside in adjacent positions, they are connected using this
  * operator.  Usually, that is OP_PHRASE, which requires word positions of
  * a complex morph to exactly match the tsvector.
 */
 int   qoperator;
} MorphOpaque;

typedef struct TSVectorBuildState
{
 ParsedText *prs;
 Oid   cfgId;
} TSVectorBuildState;

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


Datum
get_current_ts_config(PG_FUNCTION_ARGS)
{
 PG_RETURN_OID(getTSCurrentConfig(true));
}

/*
 * to_tsvector
 */
static int
compareWORD(const void *a, const void *b)
{
 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;
}

static int
uniqueWORD(ParsedWord *a, int32 l)
{
 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;
}

/*
 * make value of tsvector, given parsed text
 *
 * Note: frees prs->words and subsidiary data.
 */
TSVector
make_tsvector(ParsedText *prs)
{
 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;
}

Datum
to_tsvector_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
to_tsvector(PG_FUNCTION_ARGS)
{
 text    *in = PG_GETARG_TEXT_PP(0);
 Oid   cfgId;

 cfgId = getTSCurrentConfig(true);
 PG_RETURN_DATUM(DirectFunctionCall2(to_tsvector_byid,
          ObjectIdGetDatum(cfgId),
          PointerGetDatum(in)));
}

/*
 * Worker function for jsonb(_string)_to_tsvector(_byid)
 */
static TSVector
jsonb_to_tsvector_worker(Oid cfgId, Jsonb *jb, uint32 flags)
{
 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);
}

Datum
jsonb_string_to_tsvector_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
jsonb_string_to_tsvector(PG_FUNCTION_ARGS)
{
 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);
}

Datum
jsonb_to_tsvector_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
jsonb_to_tsvector(PG_FUNCTION_ARGS)
{
 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);
}

/*
 * Worker function for json(_string)_to_tsvector(_byid)
 */
static TSVector
json_to_tsvector_worker(Oid cfgId, text *json, uint32 flags)
{
 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);
}

Datum
json_string_to_tsvector_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
json_string_to_tsvector(PG_FUNCTION_ARGS)
{
 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);
}

Datum
json_to_tsvector_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
json_to_tsvector(PG_FUNCTION_ARGS)
{
 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);
}

/*
 * Parse lexemes in an element of a json(b) value, add to TSVectorBuildState.
 */
static void
add_to_tsvector(void *_state, char *elem_value, int elem_len)
{
 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;
}


/*
 * to_tsquery
 */


/*
 * This function is used for morph parsing.
 *
 * The value is passed to parsetext which will call the right dictionary to
 * lexize the word. If it turns out to be a stopword, we push a QI_VALSTOP
 * to the stack.
 *
 * All words belonging to the same variant are pushed as an ANDed list,
 * and different variants are ORed together.
 */
static void
pushval_morph(Datum opaque, TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
{
 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);
}

Datum
to_tsquery_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
to_tsquery(PG_FUNCTION_ARGS)
{
 text    *in = PG_GETARG_TEXT_PP(0);
 Oid   cfgId;

 cfgId = getTSCurrentConfig(true);
 PG_RETURN_DATUM(DirectFunctionCall2(to_tsquery_byid,
          ObjectIdGetDatum(cfgId),
          PointerGetDatum(in)));
}

Datum
plainto_tsquery_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
plainto_tsquery(PG_FUNCTION_ARGS)
{
 text    *in = PG_GETARG_TEXT_PP(0);
 Oid   cfgId;

 cfgId = getTSCurrentConfig(true);
 PG_RETURN_DATUM(DirectFunctionCall2(plainto_tsquery_byid,
          ObjectIdGetDatum(cfgId),
          PointerGetDatum(in)));
}


Datum
phraseto_tsquery_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
phraseto_tsquery(PG_FUNCTION_ARGS)
{
 text    *in = PG_GETARG_TEXT_PP(0);
 Oid   cfgId;

 cfgId = getTSCurrentConfig(true);
 PG_RETURN_DATUM(DirectFunctionCall2(phraseto_tsquery_byid,
          ObjectIdGetDatum(cfgId),
          PointerGetDatum(in)));
}

Datum
websearch_to_tsquery_byid(PG_FUNCTION_ARGS)
{
 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);
}

Datum
websearch_to_tsquery(PG_FUNCTION_ARGS)
{
 text    *in = PG_GETARG_TEXT_PP(0);
 Oid   cfgId;

 cfgId = getTSCurrentConfig(true);
 PG_RETURN_DATUM(DirectFunctionCall2(websearch_to_tsquery_byid,
          ObjectIdGetDatum(cfgId),
          PointerGetDatum(in)));
}