/*-------------------------------------------------------------------------
 *
 * tsginidx.c
 *  GIN support functions for tsvector_ops
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 *
 *
 * IDENTIFICATION
 *   src/backend/utils/adt/tsginidx.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "access/gin.h"
#include "tsearch/ts_type.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
#include "varatt.h"


Datum
gin_cmp_tslexeme(PG_FUNCTION_ARGS)
{
 text    *a = PG_GETARG_TEXT_PP(0);
 text    *b = PG_GETARG_TEXT_PP(1);
 int   cmp;

 cmp = tsCompareString(VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
        VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
        false);

 PG_FREE_IF_COPY(a, 0);
 PG_FREE_IF_COPY(b, 1);
 PG_RETURN_INT32(cmp);
}

Datum
gin_cmp_prefix(PG_FUNCTION_ARGS)
{
 text    *a = PG_GETARG_TEXT_PP(0);
 text    *b = PG_GETARG_TEXT_PP(1);

#ifdef NOT_USED
 StrategyNumber strategy = PG_GETARG_UINT16(2);
 Pointer  extra_data = PG_GETARG_POINTER(3);
#endif
 int   cmp;

 cmp = tsCompareString(VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
        VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
        true);

 if (cmp < 0)
  cmp = 1;    /* prevent continue scan */

 PG_FREE_IF_COPY(a, 0);
 PG_FREE_IF_COPY(b, 1);
 PG_RETURN_INT32(cmp);
}

Datum
gin_extract_tsvector(PG_FUNCTION_ARGS)
{
 TSVector vector = PG_GETARG_TSVECTOR(0);
 int32    *nentries = (int32 *) PG_GETARG_POINTER(1);
 Datum    *entries = NULL;

 *nentries = vector->size;
 if (vector->size > 0)
 {
  int   i;
  WordEntry  *we = ARRPTR(vector);

  entries = (Datum *) palloc(sizeof(Datum) * vector->size);

  for (i = 0; i < vector->size; i++)
  {
   text    *txt;

   txt = cstring_to_text_with_len(STRPTR(vector) + we->pos, we->len);
   entries[i] = PointerGetDatum(txt);

   we++;
  }
 }

 PG_FREE_IF_COPY(vector, 0);
 PG_RETURN_POINTER(entries);
}

Datum
gin_extract_tsquery(PG_FUNCTION_ARGS)
{
 TSQuery  query = PG_GETARG_TSQUERY(0);
 int32    *nentries = (int32 *) PG_GETARG_POINTER(1);

 /* StrategyNumber strategy = PG_GETARG_UINT16(2); */
 bool   **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3);
 Pointer   **extra_data = (Pointer **) PG_GETARG_POINTER(4);

 /* bool   **nullFlags = (bool **) PG_GETARG_POINTER(5); */
 int32    *searchMode = (int32 *) PG_GETARG_POINTER(6);
 Datum    *entries = NULL;

 *nentries = 0;

 if (query->size > 0)
 {
  QueryItem  *item = GETQUERY(query);
  int32  i,
     j;
  bool    *partialmatch;
  int     *map_item_operand;

  /*
   * If the query doesn't have any required positive matches (for
   * instance, it's something like '! foo'), we have to do a full index
   * scan.
 */
  if (tsquery_requires_match(item))
   *searchMode = GIN_SEARCH_MODE_DEFAULT;
  else
   *searchMode = GIN_SEARCH_MODE_ALL;

  /* count number of VAL items */
  j = 0;
  for (i = 0; i < query->size; i++)
  {
   if (item[i].type == QI_VAL)
    j++;
  }
  *nentries = j;

  entries = (Datum *) palloc(sizeof(Datum) * j);
  partialmatch = *ptr_partialmatch = (bool *) palloc(sizeof(bool) * j);

  /*
   * Make map to convert item's number to corresponding operand's (the
   * same, entry's) number. Entry's number is used in check array in
   * consistent method. We use the same map for each entry.
 */
  *extra_data = (Pointer *) palloc(sizeof(Pointer) * j);
  map_item_operand = (int *) palloc0(sizeof(int) * query->size);

  /* Now rescan the VAL items and fill in the arrays */
  j = 0;
  for (i = 0; i < query->size; i++)
  {
   if (item[i].type == QI_VAL)
   {
    QueryOperand *val = &item[i].qoperand;
    text    *txt;

    txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,
              val->length);
    entries[j] = PointerGetDatum(txt);
    partialmatch[j] = val->prefix;
    (*extra_data)[j] = (Pointer) map_item_operand;
    map_item_operand[i] = j;
    j++;
   }
  }
 }

 PG_FREE_IF_COPY(query, 0);

 PG_RETURN_POINTER(entries);
}

typedef struct
{
 QueryItem  *first_item;
 GinTernaryValue *check;
 int     *map_item_operand;
} GinChkVal;

/*
 * TS_execute callback for matching a tsquery operand to GIN index data
 */
static TSTernaryValue
checkcondition_gin(void *checkval, QueryOperand *val, ExecPhraseData *data)
{
 GinChkVal  *gcv = (GinChkVal *) checkval;
 int   j;
 GinTernaryValue result;

 /* convert item's number to corresponding entry's (operand's) number */
 j = gcv->map_item_operand[((QueryItem *) val) - gcv->first_item];

 /* determine presence of current entry in indexed value */
 result = gcv->check[j];

 /*
  * If any val requiring a weight is used or caller needs position
  * information then we must recheck, so replace TRUE with MAYBE.
 */
 if (result == GIN_TRUE)
 {
  if (val->weight != 0 || data != NULL)
   result = GIN_MAYBE;
 }

 /*
  * We rely on GinTernaryValue and TSTernaryValue using equivalent value
  * assignments.  We could use a switch statement to map the values if that
  * ever stops being true, but it seems unlikely to happen.
 */
 return (TSTernaryValue) result;
}

Datum
gin_tsquery_consistent(PG_FUNCTION_ARGS)
{
 bool    *check = (bool *) PG_GETARG_POINTER(0);

 /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
 TSQuery  query = PG_GETARG_TSQUERY(2);

 /* int32 nkeys = PG_GETARG_INT32(3); */
 Pointer    *extra_data = (Pointer *) PG_GETARG_POINTER(4);
 bool    *recheck = (bool *) PG_GETARG_POINTER(5);
 bool  res = false;

 /* Initially assume query doesn't require recheck */
 *recheck = false;

 if (query->size > 0)
 {
  GinChkVal gcv;

  /*
   * check-parameter array has one entry for each value (operand) in the
   * query.
 */
  gcv.first_item = GETQUERY(query);
  gcv.check = (GinTernaryValue *) check;
  gcv.map_item_operand = (int *) (extra_data[0]);

  switch (TS_execute_ternary(GETQUERY(query),
           &gcv,
           TS_EXEC_PHRASE_NO_POS,
           checkcondition_gin))
  {
   case TS_NO:
    res = false;
    break;
   case TS_YES:
    res = true;
    break;
   case TS_MAYBE:
    res = true;
    *recheck = true;
    break;
  }
 }

 PG_RETURN_BOOL(res);
}

Datum
gin_tsquery_triconsistent(PG_FUNCTION_ARGS)
{
 GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);

 /* StrategyNumber strategy = PG_GETARG_UINT16(1); */
 TSQuery  query = PG_GETARG_TSQUERY(2);

 /* int32 nkeys = PG_GETARG_INT32(3); */
 Pointer    *extra_data = (Pointer *) PG_GETARG_POINTER(4);
 GinTernaryValue res = GIN_FALSE;

 if (query->size > 0)
 {
  GinChkVal gcv;

  /*
   * check-parameter array has one entry for each value (operand) in the
   * query.
 */
  gcv.first_item = GETQUERY(query);
  gcv.check = check;
  gcv.map_item_operand = (int *) (extra_data[0]);

  res = TS_execute_ternary(GETQUERY(query),
         &gcv,
         TS_EXEC_PHRASE_NO_POS,
         checkcondition_gin);
 }

 PG_RETURN_GIN_TERNARY_VALUE(res);
}

/*
 * Formerly, gin_extract_tsvector had only two arguments.  Now it has three,
 * but we still need a pg_proc entry with two args to support reloading
 * pre-9.1 contrib/tsearch2 opclass declarations.  This compatibility
 * function should go away eventually.  (Note: you might say "hey, but the
 * code above is only *using* two args, so let's just declare it that way".
 * If you try that you'll find the opr_sanity regression test complains.)
 */
Datum
gin_extract_tsvector_2args(PG_FUNCTION_ARGS)
{
 if (PG_NARGS() < 3)   /* should not happen */
  elog(ERROR, "gin_extract_tsvector requires three arguments");
 return gin_extract_tsvector(fcinfo);
}

/*
 * Likewise, we need a stub version of gin_extract_tsquery declared with
 * only five arguments.
 */
Datum
gin_extract_tsquery_5args(PG_FUNCTION_ARGS)
{
 if (PG_NARGS() < 7)   /* should not happen */
  elog(ERROR, "gin_extract_tsquery requires seven arguments");
 return gin_extract_tsquery(fcinfo);
}

/*
 * Likewise, we need a stub version of gin_tsquery_consistent declared with
 * only six arguments.
 */
Datum
gin_tsquery_consistent_6args(PG_FUNCTION_ARGS)
{
 if (PG_NARGS() < 8)   /* should not happen */
  elog(ERROR, "gin_tsquery_consistent requires eight arguments");
 return gin_tsquery_consistent(fcinfo);
}

/*
 * Likewise, a stub version of gin_extract_tsquery declared with argument
 * types that are no longer considered appropriate.
 */
Datum
gin_extract_tsquery_oldsig(PG_FUNCTION_ARGS)
{
 return gin_extract_tsquery(fcinfo);
}

/*
 * Likewise, a stub version of gin_tsquery_consistent declared with argument
 * types that are no longer considered appropriate.
 */
Datum
gin_tsquery_consistent_oldsig(PG_FUNCTION_ARGS)
{
 return gin_tsquery_consistent(fcinfo);
}