/*-------------------------------------------------------------------------

 *

 * tsquery_op.c

 *    Various operations with tsquery

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 *

 *

 * IDENTIFICATION

 *    src/backend/utils/adt/tsquery_op.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "lib/qunique.h"

#include "tsearch/ts_utils.h"

#include "utils/fmgrprotos.h"

#include "varatt.h"

Datum

tsquery_numnode(PG_FUNCTION_ARGS)

{

  TSQuery   query = PG_GETARG_TSQUERY(0);

  int     nnode = query->size;

  PG_FREE_IF_COPY(query, 0);

  PG_RETURN_INT32(nnode);

}

static QTNode *

join_tsqueries(TSQuery a, TSQuery b, int8 operator, uint16 distance)

{

  QTNode     *res = (QTNode *) palloc0(sizeof(QTNode));

  res->flags |= QTN_NEEDFREE;

  res->valnode = (QueryItem *) palloc0(sizeof(QueryItem));

  res->valnode->type = QI_OPR;

  res->valnode->qoperator.oper = operator;

  if (operator == OP_PHRASE)

    res->valnode->qoperator.distance = distance;

  res->child = (QTNode **) palloc0(sizeof(QTNode *) * 2);

  res->child[0] = QT2QTN(GETQUERY(b), GETOPERAND(b));

  res->child[1] = QT2QTN(GETQUERY(a), GETOPERAND(a));

  res->nchild = 2;

  return res;

}

Datum

tsquery_and(PG_FUNCTION_ARGS)

{

  TSQuery   a = PG_GETARG_TSQUERY_COPY(0);

  TSQuery   b = PG_GETARG_TSQUERY_COPY(1);

  QTNode     *res;

  TSQuery   query;

  if (a->size == 0)

  {

    PG_FREE_IF_COPY(a, 1);

    PG_RETURN_POINTER(b);

  }

  else if (b->size == 0)

  {

    PG_FREE_IF_COPY(b, 1);

    PG_RETURN_POINTER(a);

  }

  res = join_tsqueries(a, b, OP_AND, 0);

  query = QTN2QT(res);

  QTNFree(res);

  PG_FREE_IF_COPY(a, 0);

  PG_FREE_IF_COPY(b, 1);

  PG_RETURN_TSQUERY(query);

}

Datum

tsquery_or(PG_FUNCTION_ARGS)

{

  TSQuery   a = PG_GETARG_TSQUERY_COPY(0);

  TSQuery   b = PG_GETARG_TSQUERY_COPY(1);

  QTNode     *res;

  TSQuery   query;

  if (a->size == 0)

  {

    PG_FREE_IF_COPY(a, 1);

    PG_RETURN_POINTER(b);

  }

  else if (b->size == 0)

  {

    PG_FREE_IF_COPY(b, 1);

    PG_RETURN_POINTER(a);

  }

  res = join_tsqueries(a, b, OP_OR, 0);

  query = QTN2QT(res);

  QTNFree(res);

  PG_FREE_IF_COPY(a, 0);

  PG_FREE_IF_COPY(b, 1);

  PG_RETURN_TSQUERY(query);

}

Datum

tsquery_phrase_distance(PG_FUNCTION_ARGS)

{

  TSQuery   a = PG_GETARG_TSQUERY_COPY(0);

  TSQuery   b = PG_GETARG_TSQUERY_COPY(1);

  QTNode     *res;

  TSQuery   query;

  int32   distance = PG_GETARG_INT32(2);

  if (distance < 0 || distance > MAXENTRYPOS)

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),

         errmsg("distance in phrase operator must be an integer value between zero and %d inclusive",

            MAXENTRYPOS)));

  if (a->size == 0)

  {

    PG_FREE_IF_COPY(a, 1);

    PG_RETURN_POINTER(b);

  }

  else if (b->size == 0)

  {

    PG_FREE_IF_COPY(b, 1);

    PG_RETURN_POINTER(a);

  }

  res = join_tsqueries(a, b, OP_PHRASE, (uint16) distance);

  query = QTN2QT(res);

  QTNFree(res);

  PG_FREE_IF_COPY(a, 0);

  PG_FREE_IF_COPY(b, 1);

  PG_RETURN_TSQUERY(query);

}

Datum

tsquery_phrase(PG_FUNCTION_ARGS)

{

  PG_RETURN_DATUM(DirectFunctionCall3(tsquery_phrase_distance,

                    PG_GETARG_DATUM(0),

                    PG_GETARG_DATUM(1),

                    Int32GetDatum(1)));

}

Datum

tsquery_not(PG_FUNCTION_ARGS)

{

  TSQuery   a = PG_GETARG_TSQUERY_COPY(0);

  QTNode     *res;

  TSQuery   query;

  if (a->size == 0)

    PG_RETURN_POINTER(a);

  res = (QTNode *) palloc0(sizeof(QTNode));

  res->flags |= QTN_NEEDFREE;

  res->valnode = (QueryItem *) palloc0(sizeof(QueryItem));

  res->valnode->type = QI_OPR;

  res->valnode->qoperator.oper = OP_NOT;

  res->child = (QTNode **) palloc0(sizeof(QTNode *));

  res->child[0] = QT2QTN(GETQUERY(a), GETOPERAND(a));

  res->nchild = 1;

  query = QTN2QT(res);

  QTNFree(res);

  PG_FREE_IF_COPY(a, 0);

  PG_RETURN_POINTER(query);

}

static int

CompareTSQ(TSQuery a, TSQuery b)

{

  if (a->size != b->size)

  {

    return (a->size < b->size) ? -1 : 1;

  }

  else if (VARSIZE(a) != VARSIZE(b))

  {

    return (VARSIZE(a) < VARSIZE(b)) ? -1 : 1;

  }

  else if (a->size != 0)

  {

    QTNode     *an = QT2QTN(GETQUERY(a), GETOPERAND(a));

    QTNode     *bn = QT2QTN(GETQUERY(b), GETOPERAND(b));

    int     res = QTNodeCompare(an, bn);

    QTNFree(an);

    QTNFree(bn);

    return res;

  }

  return 0;

}

Datum

tsquery_cmp(PG_FUNCTION_ARGS)

{

  TSQuery   a = PG_GETARG_TSQUERY_COPY(0);

  TSQuery   b = PG_GETARG_TSQUERY_COPY(1);

  int     res = CompareTSQ(a, b);

  PG_FREE_IF_COPY(a, 0);

  PG_FREE_IF_COPY(b, 1);

  PG_RETURN_INT32(res);

}

#define CMPFUNC( NAME, CONDITION )        \

Datum                     \

NAME(PG_FUNCTION_ARGS) {           \

  TSQuery  a = PG_GETARG_TSQUERY_COPY(0);    \

  TSQuery  b = PG_GETARG_TSQUERY_COPY(1);    \

  int res = CompareTSQ(a,b);          \

                        \

  PG_FREE_IF_COPY(a,0);            \

  PG_FREE_IF_COPY(b,1);            \

                        \

  PG_RETURN_BOOL( CONDITION );        \

}  \

Unexecuted instantiation: tsquery_lt

Unexecuted instantiation: tsquery_le

Unexecuted instantiation: tsquery_eq

Unexecuted instantiation: tsquery_ge

Unexecuted instantiation: tsquery_gt

Unexecuted instantiation: tsquery_ne

/* keep compiler quiet - no extra ; */      \

extern int no_such_variable

CMPFUNC(tsquery_lt, res < 0);

CMPFUNC(tsquery_le, res <= 0);

CMPFUNC(tsquery_eq, res == 0);

CMPFUNC(tsquery_ge, res >= 0);

CMPFUNC(tsquery_gt, res > 0);

CMPFUNC(tsquery_ne, res != 0);

TSQuerySign

makeTSQuerySign(TSQuery a)

{

  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;

}

static char **

collectTSQueryValues(TSQuery a, int *nvalues_p)

{

  QueryItem  *ptr = GETQUERY(a);

  char     *operand = GETOPERAND(a);

  char    **values;

  int     nvalues = 0;

  int     i;

  values = (char **) palloc(sizeof(char *) * a->size);

  for (i = 0; i < a->size; i++)

  {

    if (ptr->type == QI_VAL)

    {

      int     len = ptr->qoperand.length;

      char     *val;

      val = palloc(len + 1);

      memcpy(val, operand + ptr->qoperand.distance, len);

      val[len] = '\0';

      values[nvalues++] = val;

    }

    ptr++;

  }

  *nvalues_p = nvalues;

  return values;

}

static int

cmp_string(const void *a, const void *b)

{

  const char *sa = *((char *const *) a);

  const char *sb = *((char *const *) b);

  return strcmp(sa, sb);

}

Datum

tsq_mcontains(PG_FUNCTION_ARGS)

{

  TSQuery   query = PG_GETARG_TSQUERY(0);

  TSQuery   ex = PG_GETARG_TSQUERY(1);

  char    **query_values;

  int     query_nvalues;

  char    **ex_values;

  int     ex_nvalues;

  bool    result = true;

  /* Extract the query terms into arrays */

  query_values = collectTSQueryValues(query, &query_nvalues);

  ex_values = collectTSQueryValues(ex, &ex_nvalues);

  /* Sort and remove duplicates from both arrays */

  qsort(query_values, query_nvalues, sizeof(char *), cmp_string);

  query_nvalues = qunique(query_values, query_nvalues, sizeof(char *),

              cmp_string);

  qsort(ex_values, ex_nvalues, sizeof(char *), cmp_string);

  ex_nvalues = qunique(ex_values, ex_nvalues, sizeof(char *), cmp_string);

  if (ex_nvalues > query_nvalues)

    result = false;

  else

  {

    int     i;

    int     j = 0;

    for (i = 0; i < ex_nvalues; i++)

    {

      for (; j < query_nvalues; j++)

      {

        if (strcmp(ex_values[i], query_values[j]) == 0)

          break;

      }

      if (j == query_nvalues)

      {

        result = false;

        break;

      }

    }

  }

  PG_RETURN_BOOL(result);

}

Datum

tsq_mcontained(PG_FUNCTION_ARGS)

{

  PG_RETURN_DATUM(DirectFunctionCall2(tsq_mcontains,

                    PG_GETARG_DATUM(1),

                    PG_GETARG_DATUM(0)));

}