/*-------------------------------------------------------------------------
 *
 * tsgistidx.c
 *   GiST support functions for tsvector_ops
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 *
 *
 * IDENTIFICATION
 *   src/backend/utils/adt/tsgistidx.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "access/gist.h"
#include "access/heaptoast.h"
#include "access/reloptions.h"
#include "common/int.h"
#include "lib/qunique.h"
#include "port/pg_bitutils.h"
#include "tsearch/ts_utils.h"
#include "utils/fmgrprotos.h"
#include "utils/pg_crc.h"


/* tsvector_ops opclass options */
typedef struct
{
 int32  vl_len_;  /* varlena header (do not touch directly!) */
 int   siglen;   /* signature length */
} GistTsVectorOptions;

#define SIGLEN_DEFAULT (31 * 4)
#define SIGLEN_MAX  GISTMaxIndexKeySize
#define GET_SIGLEN() (PG_HAS_OPCLASS_OPTIONS() ? \
       ((GistTsVectorOptions *) PG_GET_OPCLASS_OPTIONS())->siglen : \
       SIGLEN_DEFAULT)

#define SIGLENBIT(siglen) ((siglen) * BITS_PER_BYTE)

typedef char *BITVECP;

#define LOOPBYTE(siglen) \
   for (i = 0; i < siglen; i++)

#define GETBYTE(x,i) ( *( (BITVECP)(x) + (int)( (i) / BITS_PER_BYTE ) ) )
#define GETBITBYTE(x,i) ( ((char)(x)) >> (i) & 0x01 )
#define CLRBIT(x,i)   GETBYTE(x,i) &= ~( 0x01 << ( (i) % BITS_PER_BYTE ) )
#define SETBIT(x,i)   GETBYTE(x,i) |=  ( 0x01 << ( (i) % BITS_PER_BYTE ) )
#define GETBIT(x,i) ( (GETBYTE(x,i) >> ( (i) % BITS_PER_BYTE )) & 0x01 )

#define HASHVAL(val, siglen) (((unsigned int)(val)) % SIGLENBIT(siglen))
#define HASH(sign, val, siglen) SETBIT((sign), HASHVAL(val, siglen))

#define GETENTRY(vec,pos) ((SignTSVector *) DatumGetPointer((vec)->vector[(pos)].key))

/*
 * type of GiST index key
 */

typedef struct
{
 int32  vl_len_;  /* varlena header (do not touch directly!) */
 int32  flag;
 char  data[FLEXIBLE_ARRAY_MEMBER];
} SignTSVector;

#define ARRKEY  0x01
#define SIGNKEY  0x02
#define ALLISTRUE 0x04

#define ISARRKEY(x) ( ((SignTSVector*)(x))->flag & ARRKEY )
#define ISSIGNKEY(x) ( ((SignTSVector*)(x))->flag & SIGNKEY )
#define ISALLTRUE(x) ( ((SignTSVector*)(x))->flag & ALLISTRUE )

#define GTHDRSIZE ( VARHDRSZ + sizeof(int32) )
#define CALCGTSIZE(flag, len) ( GTHDRSIZE + ( ( (flag) & ARRKEY ) ? ((len)*sizeof(int32)) : (((flag) & ALLISTRUE) ? 0 : (len)) ) )

#define GETSIGN(x) ( (BITVECP)( (char*)(x)+GTHDRSIZE ) )
#define GETSIGLEN(x)( VARSIZE(x) - GTHDRSIZE )
#define GETARR(x) ( (int32*)( (char*)(x)+GTHDRSIZE ) )
#define ARRNELEM(x) ( ( VARSIZE(x) - GTHDRSIZE )/sizeof(int32) )

static int32 sizebitvec(BITVECP sign, int siglen);

Datum
gtsvectorin(PG_FUNCTION_ARGS)
{
 /* There's no need to support input of gtsvectors */
 ereport(ERROR,
   (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    errmsg("cannot accept a value of type %s", "gtsvector")));

 PG_RETURN_VOID();   /* keep compiler quiet */
}

Datum
gtsvectorout(PG_FUNCTION_ARGS)
{
 SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(PG_GETARG_DATUM(0));
 char    *outbuf;

 if (ISARRKEY(key))
  outbuf = psprintf("%d unique words", (int) ARRNELEM(key));
 else
 {
  if (ISALLTRUE(key))
   outbuf = pstrdup("all true bits");
  else
  {
   int   siglen = GETSIGLEN(key);
   int   cnttrue = sizebitvec(GETSIGN(key), siglen);

   outbuf = psprintf("%d true bits, %d false bits",
         cnttrue, (int) SIGLENBIT(siglen) - cnttrue);
  }
 }

 PG_FREE_IF_COPY(key, 0);
 PG_RETURN_POINTER(outbuf);
}

static int
compareint(const void *va, const void *vb)
{
 int32  a = *((const int32 *) va);
 int32  b = *((const int32 *) vb);

 return pg_cmp_s32(a, b);
}

static void
makesign(BITVECP sign, SignTSVector *a, int siglen)
{
 int32  k,
    len = ARRNELEM(a);
 int32    *ptr = GETARR(a);

 MemSet(sign, 0, siglen);
 for (k = 0; k < len; k++)
  HASH(sign, ptr[k], siglen);
}

static SignTSVector *
gtsvector_alloc(int flag, int len, BITVECP sign)
{
 int   size = CALCGTSIZE(flag, len);
 SignTSVector *res = palloc(size);

 SET_VARSIZE(res, size);
 res->flag = flag;

 if ((flag & (SIGNKEY | ALLISTRUE)) == SIGNKEY && sign)
  memcpy(GETSIGN(res), sign, len);

 return res;
}


Datum
gtsvector_compress(PG_FUNCTION_ARGS)
{
 GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 int   siglen = GET_SIGLEN();
 GISTENTRY  *retval = entry;

 if (entry->leafkey)
 {       /* tsvector */
  TSVector val = DatumGetTSVector(entry->key);
  SignTSVector *res = gtsvector_alloc(ARRKEY, val->size, NULL);
  int32  len;
  int32    *arr;
  WordEntry  *ptr = ARRPTR(val);
  char    *words = STRPTR(val);

  arr = GETARR(res);
  len = val->size;
  while (len--)
  {
   pg_crc32 c;

   INIT_LEGACY_CRC32(c);
   COMP_LEGACY_CRC32(c, words + ptr->pos, ptr->len);
   FIN_LEGACY_CRC32(c);

   *arr = *(int32 *) &c;
   arr++;
   ptr++;
  }

  qsort(GETARR(res), val->size, sizeof(int), compareint);
  len = qunique(GETARR(res), val->size, sizeof(int), compareint);
  if (len != val->size)
  {
   /*
    * there is a collision of hash-function; len is always less than
    * val->size
 */
   len = CALCGTSIZE(ARRKEY, len);
   res = (SignTSVector *) repalloc(res, len);
   SET_VARSIZE(res, len);
  }

  /* make signature, if array is too long */
  if (VARSIZE(res) > TOAST_INDEX_TARGET)
  {
   SignTSVector *ressign = gtsvector_alloc(SIGNKEY, siglen, NULL);

   makesign(GETSIGN(ressign), res, siglen);
   res = ressign;
  }

  retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
  gistentryinit(*retval, PointerGetDatum(res),
       entry->rel, entry->page,
       entry->offset, false);
 }
 else if (ISSIGNKEY(DatumGetPointer(entry->key)) &&
    !ISALLTRUE(DatumGetPointer(entry->key)))
 {
  int32  i;
  SignTSVector *res;
  BITVECP  sign = GETSIGN(DatumGetPointer(entry->key));

  LOOPBYTE(siglen)
  {
   if ((sign[i] & 0xff) != 0xff)
    PG_RETURN_POINTER(retval);
  }

  res = gtsvector_alloc(SIGNKEY | ALLISTRUE, siglen, sign);
  retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
  gistentryinit(*retval, PointerGetDatum(res),
       entry->rel, entry->page,
       entry->offset, false);
 }
 PG_RETURN_POINTER(retval);
}

Datum
gtsvector_decompress(PG_FUNCTION_ARGS)
{
 /*
  * We need to detoast the stored value, because the other gtsvector
  * support functions don't cope with toasted values.
 */
 GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(entry->key);

 if (key != (SignTSVector *) DatumGetPointer(entry->key))
 {
  GISTENTRY  *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));

  gistentryinit(*retval, PointerGetDatum(key),
       entry->rel, entry->page,
       entry->offset, false);

  PG_RETURN_POINTER(retval);
 }

 PG_RETURN_POINTER(entry);
}

typedef struct
{
 int32    *arrb;
 int32    *arre;
} CHKVAL;

/*
 * TS_execute callback for matching a tsquery operand to GIST leaf-page data
 */
static TSTernaryValue
checkcondition_arr(void *checkval, QueryOperand *val, ExecPhraseData *data)
{
 int32    *StopLow = ((CHKVAL *) checkval)->arrb;
 int32    *StopHigh = ((CHKVAL *) checkval)->arre;
 int32    *StopMiddle;

 /* Loop invariant: StopLow <= val < StopHigh */

 /*
  * we are not able to find a prefix by hash value
 */
 if (val->prefix)
  return TS_MAYBE;

 while (StopLow < StopHigh)
 {
  StopMiddle = StopLow + (StopHigh - StopLow) / 2;
  if (*StopMiddle == val->valcrc)
   return TS_MAYBE;
  else if (*StopMiddle < val->valcrc)
   StopLow = StopMiddle + 1;
  else
   StopHigh = StopMiddle;
 }

 return TS_NO;
}

/*
 * TS_execute callback for matching a tsquery operand to GIST non-leaf data
 */
static TSTernaryValue
checkcondition_bit(void *checkval, QueryOperand *val, ExecPhraseData *data)
{
 void    *key = (SignTSVector *) checkval;

 /*
  * we are not able to find a prefix in signature tree
 */
 if (val->prefix)
  return TS_MAYBE;

 if (GETBIT(GETSIGN(key), HASHVAL(val->valcrc, GETSIGLEN(key))))
  return TS_MAYBE;
 else
  return TS_NO;
}

Datum
gtsvector_consistent(PG_FUNCTION_ARGS)
{
 GISTENTRY  *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
 TSQuery  query = PG_GETARG_TSQUERY(1);

 /* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
 /* Oid subtype = PG_GETARG_OID(3); */
 bool    *recheck = (bool *) PG_GETARG_POINTER(4);
 SignTSVector *key = (SignTSVector *) DatumGetPointer(entry->key);

 /* All cases served by this function are inexact */
 *recheck = true;

 if (!query->size)
  PG_RETURN_BOOL(false);

 if (ISSIGNKEY(key))
 {
  if (ISALLTRUE(key))
   PG_RETURN_BOOL(true);

  PG_RETURN_BOOL(TS_execute(GETQUERY(query),
          key,
          TS_EXEC_PHRASE_NO_POS,
          checkcondition_bit));
 }
 else
 {       /* only leaf pages */
  CHKVAL  chkval;

  chkval.arrb = GETARR(key);
  chkval.arre = chkval.arrb + ARRNELEM(key);
  PG_RETURN_BOOL(TS_execute(GETQUERY(query),
          &chkval,
          TS_EXEC_PHRASE_NO_POS,
          checkcondition_arr));
 }
}

static int32
unionkey(BITVECP sbase, SignTSVector *add, int siglen)
{
 int32  i;

 if (ISSIGNKEY(add))
 {
  BITVECP  sadd = GETSIGN(add);

  if (ISALLTRUE(add))
   return 1;

  Assert(GETSIGLEN(add) == siglen);

  LOOPBYTE(siglen)
   sbase[i] |= sadd[i];
 }
 else
 {
  int32    *ptr = GETARR(add);

  for (i = 0; i < ARRNELEM(add); i++)
   HASH(sbase, ptr[i], siglen);
 }
 return 0;
}


Datum
gtsvector_union(PG_FUNCTION_ARGS)
{
 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
 int     *size = (int *) PG_GETARG_POINTER(1);
 int   siglen = GET_SIGLEN();
 SignTSVector *result = gtsvector_alloc(SIGNKEY, siglen, NULL);
 BITVECP  base = GETSIGN(result);
 int32  i;

 memset(base, 0, siglen);

 for (i = 0; i < entryvec->n; i++)
 {
  if (unionkey(base, GETENTRY(entryvec, i), siglen))
  {
   result->flag |= ALLISTRUE;
   SET_VARSIZE(result, CALCGTSIZE(result->flag, siglen));
   break;
  }
 }

 *size = VARSIZE(result);

 PG_RETURN_POINTER(result);
}

Datum
gtsvector_same(PG_FUNCTION_ARGS)
{
 SignTSVector *a = (SignTSVector *) PG_GETARG_POINTER(0);
 SignTSVector *b = (SignTSVector *) PG_GETARG_POINTER(1);
 bool    *result = (bool *) PG_GETARG_POINTER(2);
 int   siglen = GET_SIGLEN();

 if (ISSIGNKEY(a))
 {       /* then b also ISSIGNKEY */
  if (ISALLTRUE(a) && ISALLTRUE(b))
   *result = true;
  else if (ISALLTRUE(a))
   *result = false;
  else if (ISALLTRUE(b))
   *result = false;
  else
  {
   int32  i;
   BITVECP  sa = GETSIGN(a),
      sb = GETSIGN(b);

   Assert(GETSIGLEN(a) == siglen && GETSIGLEN(b) == siglen);

   *result = true;
   LOOPBYTE(siglen)
   {
    if (sa[i] != sb[i])
    {
     *result = false;
     break;
    }
   }
  }
 }
 else
 {       /* a and b ISARRKEY */
  int32  lena = ARRNELEM(a),
     lenb = ARRNELEM(b);

  if (lena != lenb)
   *result = false;
  else
  {
   int32    *ptra = GETARR(a),
        *ptrb = GETARR(b);
   int32  i;

   *result = true;
   for (i = 0; i < lena; i++)
    if (ptra[i] != ptrb[i])
    {
     *result = false;
     break;
    }
  }
 }

 PG_RETURN_POINTER(result);
}

static int32
sizebitvec(BITVECP sign, int siglen)
{
 return pg_popcount(sign, siglen);
}

static int
hemdistsign(BITVECP a, BITVECP b, int siglen)
{
 int   i,
    diff,
    dist = 0;

 LOOPBYTE(siglen)
 {
  diff = (unsigned char) (a[i] ^ b[i]);
  /* Using the popcount functions here isn't likely to win */
  dist += pg_number_of_ones[diff];
 }
 return dist;
}

static int
hemdist(SignTSVector *a, SignTSVector *b)
{
 int   siglena = GETSIGLEN(a);
 int   siglenb = GETSIGLEN(b);

 if (ISALLTRUE(a))
 {
  if (ISALLTRUE(b))
   return 0;
  else
   return SIGLENBIT(siglenb) - sizebitvec(GETSIGN(b), siglenb);
 }
 else if (ISALLTRUE(b))
  return SIGLENBIT(siglena) - sizebitvec(GETSIGN(a), siglena);

 Assert(siglena == siglenb);

 return hemdistsign(GETSIGN(a), GETSIGN(b), siglena);
}

Datum
gtsvector_penalty(PG_FUNCTION_ARGS)
{
 GISTENTRY  *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */
 GISTENTRY  *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
 float    *penalty = (float *) PG_GETARG_POINTER(2);
 int   siglen = GET_SIGLEN();
 SignTSVector *origval = (SignTSVector *) DatumGetPointer(origentry->key);
 SignTSVector *newval = (SignTSVector *) DatumGetPointer(newentry->key);
 BITVECP  orig = GETSIGN(origval);

 *penalty = 0.0;

 if (ISARRKEY(newval))
 {
  BITVECP  sign = palloc(siglen);

  makesign(sign, newval, siglen);

  if (ISALLTRUE(origval))
  {
   int   siglenbit = SIGLENBIT(siglen);

   *penalty =
    (float) (siglenbit - sizebitvec(sign, siglen)) /
    (float) (siglenbit + 1);
  }
  else
   *penalty = hemdistsign(sign, orig, siglen);

  pfree(sign);
 }
 else
  *penalty = hemdist(origval, newval);
 PG_RETURN_POINTER(penalty);
}

typedef struct
{
 bool  allistrue;
 BITVECP  sign;
} CACHESIGN;

static void
fillcache(CACHESIGN *item, SignTSVector *key, int siglen)
{
 item->allistrue = false;
 if (ISARRKEY(key))
  makesign(item->sign, key, siglen);
 else if (ISALLTRUE(key))
  item->allistrue = true;
 else
  memcpy(item->sign, GETSIGN(key), siglen);
}

#define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) )
typedef struct
{
 OffsetNumber pos;
 int32  cost;
} SPLITCOST;

static int
comparecost(const void *va, const void *vb)
{
 const SPLITCOST *a = (const SPLITCOST *) va;
 const SPLITCOST *b = (const SPLITCOST *) vb;

 return pg_cmp_s32(a->cost, b->cost);
}


static int
hemdistcache(CACHESIGN *a, CACHESIGN *b, int siglen)
{
 if (a->allistrue)
 {
  if (b->allistrue)
   return 0;
  else
   return SIGLENBIT(siglen) - sizebitvec(b->sign, siglen);
 }
 else if (b->allistrue)
  return SIGLENBIT(siglen) - sizebitvec(a->sign, siglen);

 return hemdistsign(a->sign, b->sign, siglen);
}

Datum
gtsvector_picksplit(PG_FUNCTION_ARGS)
{
 GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
 GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
 int   siglen = GET_SIGLEN();
 OffsetNumber k,
    j;
 SignTSVector *datum_l,
      *datum_r;
 BITVECP  union_l,
    union_r;
 int32  size_alpha,
    size_beta;
 int32  size_waste,
    waste = -1;
 int32  nbytes;
 OffsetNumber seed_1 = 0,
    seed_2 = 0;
 OffsetNumber *left,
      *right;
 OffsetNumber maxoff;
 BITVECP  ptr;
 int   i;
 CACHESIGN  *cache;
 char    *cache_sign;
 SPLITCOST  *costvector;

 maxoff = entryvec->n - 2;
 nbytes = (maxoff + 2) * sizeof(OffsetNumber);
 v->spl_left = (OffsetNumber *) palloc(nbytes);
 v->spl_right = (OffsetNumber *) palloc(nbytes);

 cache = (CACHESIGN *) palloc(sizeof(CACHESIGN) * (maxoff + 2));
 cache_sign = palloc(siglen * (maxoff + 2));

 for (j = 0; j < maxoff + 2; j++)
  cache[j].sign = &cache_sign[siglen * j];

 fillcache(&cache[FirstOffsetNumber], GETENTRY(entryvec, FirstOffsetNumber),
     siglen);

 for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k))
 {
  for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j))
  {
   if (k == FirstOffsetNumber)
    fillcache(&cache[j], GETENTRY(entryvec, j), siglen);

   size_waste = hemdistcache(&(cache[j]), &(cache[k]), siglen);
   if (size_waste > waste)
   {
    waste = size_waste;
    seed_1 = k;
    seed_2 = j;
   }
  }
 }

 left = v->spl_left;
 v->spl_nleft = 0;
 right = v->spl_right;
 v->spl_nright = 0;

 if (seed_1 == 0 || seed_2 == 0)
 {
  seed_1 = 1;
  seed_2 = 2;
 }

 /* form initial .. */
 datum_l = gtsvector_alloc(SIGNKEY | (cache[seed_1].allistrue ? ALLISTRUE : 0),
         siglen, cache[seed_1].sign);
 datum_r = gtsvector_alloc(SIGNKEY | (cache[seed_2].allistrue ? ALLISTRUE : 0),
         siglen, cache[seed_2].sign);
 union_l = GETSIGN(datum_l);
 union_r = GETSIGN(datum_r);
 maxoff = OffsetNumberNext(maxoff);
 fillcache(&cache[maxoff], GETENTRY(entryvec, maxoff), siglen);
 /* sort before ... */
 costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
 for (j = FirstOffsetNumber; j <= maxoff; j = OffsetNumberNext(j))
 {
  costvector[j - 1].pos = j;
  size_alpha = hemdistcache(&(cache[seed_1]), &(cache[j]), siglen);
  size_beta = hemdistcache(&(cache[seed_2]), &(cache[j]), siglen);
  costvector[j - 1].cost = abs(size_alpha - size_beta);
 }
 qsort(costvector, maxoff, sizeof(SPLITCOST), comparecost);

 for (k = 0; k < maxoff; k++)
 {
  j = costvector[k].pos;
  if (j == seed_1)
  {
   *left++ = j;
   v->spl_nleft++;
   continue;
  }
  else if (j == seed_2)
  {
   *right++ = j;
   v->spl_nright++;
   continue;
  }

  if (ISALLTRUE(datum_l) || cache[j].allistrue)
  {
   if (ISALLTRUE(datum_l) && cache[j].allistrue)
    size_alpha = 0;
   else
    size_alpha = SIGLENBIT(siglen) -
     sizebitvec((cache[j].allistrue) ?
          GETSIGN(datum_l) :
          cache[j].sign,
          siglen);
  }
  else
   size_alpha = hemdistsign(cache[j].sign, GETSIGN(datum_l), siglen);

  if (ISALLTRUE(datum_r) || cache[j].allistrue)
  {
   if (ISALLTRUE(datum_r) && cache[j].allistrue)
    size_beta = 0;
   else
    size_beta = SIGLENBIT(siglen) -
     sizebitvec((cache[j].allistrue) ?
          GETSIGN(datum_r) :
          cache[j].sign,
          siglen);
  }
  else
   size_beta = hemdistsign(cache[j].sign, GETSIGN(datum_r), siglen);

  if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.1))
  {
   if (ISALLTRUE(datum_l) || cache[j].allistrue)
   {
    if (!ISALLTRUE(datum_l))
     memset(GETSIGN(datum_l), 0xff, siglen);
   }
   else
   {
    ptr = cache[j].sign;
    LOOPBYTE(siglen)
     union_l[i] |= ptr[i];
   }
   *left++ = j;
   v->spl_nleft++;
  }
  else
  {
   if (ISALLTRUE(datum_r) || cache[j].allistrue)
   {
    if (!ISALLTRUE(datum_r))
     memset(GETSIGN(datum_r), 0xff, siglen);
   }
   else
   {
    ptr = cache[j].sign;
    LOOPBYTE(siglen)
     union_r[i] |= ptr[i];
   }
   *right++ = j;
   v->spl_nright++;
  }
 }

 *right = *left = FirstOffsetNumber;
 v->spl_ldatum = PointerGetDatum(datum_l);
 v->spl_rdatum = PointerGetDatum(datum_r);

 PG_RETURN_POINTER(v);
}

/*
 * Formerly, gtsvector_consistent was declared in pg_proc.h with arguments
 * that did not match the documented conventions for GiST support functions.
 * We fixed that, but we still need a pg_proc entry with the old signature
 * to support reloading pre-9.6 contrib/tsearch2 opclass declarations.
 * This compatibility function should go away eventually.
 */
Datum
gtsvector_consistent_oldsig(PG_FUNCTION_ARGS)
{
 return gtsvector_consistent(fcinfo);
}

Datum
gtsvector_options(PG_FUNCTION_ARGS)
{
 local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);

 init_local_reloptions(relopts, sizeof(GistTsVectorOptions));
 add_local_int_reloption(relopts, "siglen", "signature length",
       SIGLEN_DEFAULT, 1, SIGLEN_MAX,
       offsetof(GistTsVectorOptions, siglen));

 PG_RETURN_VOID();
}