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

 *

 * ts_cache.c

 *    Tsearch related object caches.

 *

 * Tsearch performance is very sensitive to performance of parsers,

 * dictionaries and mapping, so lookups should be cached as much

 * as possible.

 *

 * Once a backend has created a cache entry for a particular TS object OID,

 * the cache entry will exist for the life of the backend; hence it is

 * safe to hold onto a pointer to the cache entry while doing things that

 * might result in recognizing a cache invalidation.  Beware however that

 * subsidiary information might be deleted and reallocated somewhere else

 * if a cache inval and reval happens!  This does not look like it will be

 * a big problem as long as parser and dictionary methods do not attempt

 * any database access.

 *

 *

 * Copyright (c) 2006-2026, PostgreSQL Global Development Group

 *

 * IDENTIFICATION

 *    src/backend/utils/cache/ts_cache.c

 *

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

 */

#include "postgres.h"

#include "access/genam.h"

#include "access/htup_details.h"

#include "access/table.h"

#include "access/xact.h"

#include "catalog/namespace.h"

#include "catalog/pg_ts_config.h"

#include "catalog/pg_ts_config_map.h"

#include "catalog/pg_ts_dict.h"

#include "catalog/pg_ts_parser.h"

#include "catalog/pg_ts_template.h"

#include "commands/defrem.h"

#include "miscadmin.h"

#include "nodes/miscnodes.h"

#include "tsearch/ts_cache.h"

#include "utils/builtins.h"

#include "utils/catcache.h"

#include "utils/fmgroids.h"

#include "utils/guc_hooks.h"

#include "utils/hsearch.h"

#include "utils/inval.h"

#include "utils/lsyscache.h"

#include "utils/memutils.h"

#include "utils/regproc.h"

#include "utils/syscache.h"

/*

 * MAXTOKENTYPE/MAXDICTSPERTT are arbitrary limits on the workspace size

 * used in lookup_ts_config_cache().  We could avoid hardwiring a limit

 * by making the workspace dynamically enlargeable, but it seems unlikely

 * to be worth the trouble.

 */

#define MAXTOKENTYPE  256

#define MAXDICTSPERTT 100

static HTAB *TSParserCacheHash = NULL;

static TSParserCacheEntry *lastUsedParser = NULL;

static HTAB *TSDictionaryCacheHash = NULL;

static TSDictionaryCacheEntry *lastUsedDictionary = NULL;

static HTAB *TSConfigCacheHash = NULL;

static TSConfigCacheEntry *lastUsedConfig = NULL;

/*

 * GUC default_text_search_config, and a cache of the current config's OID

 */

char     *TSCurrentConfig = NULL;

static Oid  TSCurrentConfigCache = InvalidOid;

/*

 * We use this syscache callback to detect when a visible change to a TS

 * catalog entry has been made, by either our own backend or another one.

 *

 * In principle we could just flush the specific cache entry that changed,

 * but given that TS configuration changes are probably infrequent, it

 * doesn't seem worth the trouble to determine that; we just flush all the

 * entries of the related hash table.

 *

 * We can use the same function for all TS caches by passing the hash

 * table address as the "arg".

 */

static void

InvalidateTSCacheCallBack(Datum arg, SysCacheIdentifier cacheid, uint32 hashvalue)

{

  HTAB     *hash = (HTAB *) DatumGetPointer(arg);

  HASH_SEQ_STATUS status;

  TSAnyCacheEntry *entry;

  hash_seq_init(&status, hash);

  while ((entry = (TSAnyCacheEntry *) hash_seq_search(&status)) != NULL)

    entry->isvalid = false;

  /* Also invalidate the current-config cache if it's pg_ts_config */

  if (hash == TSConfigCacheHash)

    TSCurrentConfigCache = InvalidOid;

}

/*

 * Fetch parser cache entry

 */

TSParserCacheEntry *

lookup_ts_parser_cache(Oid prsId)

{

  TSParserCacheEntry *entry;

  if (TSParserCacheHash == NULL)

  {

    /* First time through: initialize the hash table */

    HASHCTL   ctl;

    ctl.keysize = sizeof(Oid);

    ctl.entrysize = sizeof(TSParserCacheEntry);

    TSParserCacheHash = hash_create("Tsearch parser cache", 4,

                    &ctl, HASH_ELEM | HASH_BLOBS);

    /* Flush cache on pg_ts_parser changes */

    CacheRegisterSyscacheCallback(TSPARSEROID, InvalidateTSCacheCallBack,

                    PointerGetDatum(TSParserCacheHash));

    /* Also make sure CacheMemoryContext exists */

    if (!CacheMemoryContext)

      CreateCacheMemoryContext();

  }

  /* Check single-entry cache */

  if (lastUsedParser && lastUsedParser->prsId == prsId &&

    lastUsedParser->isvalid)

    return lastUsedParser;

  /* Try to look up an existing entry */

  entry = (TSParserCacheEntry *) hash_search(TSParserCacheHash,

                         &prsId,

                         HASH_FIND, NULL);

  if (entry == NULL || !entry->isvalid)

  {

    /*

     * If we didn't find one, we want to make one. But first look up the

     * object to be sure the OID is real.

     */

    HeapTuple tp;

    Form_pg_ts_parser prs;

    tp = SearchSysCache1(TSPARSEROID, ObjectIdGetDatum(prsId));

    if (!HeapTupleIsValid(tp))

      elog(ERROR, "cache lookup failed for text search parser %u",

         prsId);

    prs = (Form_pg_ts_parser) GETSTRUCT(tp);

    /*

     * Sanity checks

     */

    if (!OidIsValid(prs->prsstart))

      elog(ERROR, "text search parser %u has no prsstart method", prsId);

    if (!OidIsValid(prs->prstoken))

      elog(ERROR, "text search parser %u has no prstoken method", prsId);

    if (!OidIsValid(prs->prsend))

      elog(ERROR, "text search parser %u has no prsend method", prsId);

    if (entry == NULL)

    {

      bool    found;

      /* Now make the cache entry */

      entry = (TSParserCacheEntry *)

        hash_search(TSParserCacheHash, &prsId, HASH_ENTER, &found);

      Assert(!found);   /* it wasn't there a moment ago */

    }

    MemSet(entry, 0, sizeof(TSParserCacheEntry));

    entry->prsId = prsId;

    entry->startOid = prs->prsstart;

    entry->tokenOid = prs->prstoken;

    entry->endOid = prs->prsend;

    entry->headlineOid = prs->prsheadline;

    entry->lextypeOid = prs->prslextype;

    ReleaseSysCache(tp);

    fmgr_info_cxt(entry->startOid, &entry->prsstart, CacheMemoryContext);

    fmgr_info_cxt(entry->tokenOid, &entry->prstoken, CacheMemoryContext);

    fmgr_info_cxt(entry->endOid, &entry->prsend, CacheMemoryContext);

    if (OidIsValid(entry->headlineOid))

      fmgr_info_cxt(entry->headlineOid, &entry->prsheadline,

              CacheMemoryContext);

    entry->isvalid = true;

  }

  lastUsedParser = entry;

  return entry;

}

/*

 * Fetch dictionary cache entry

 */

TSDictionaryCacheEntry *

lookup_ts_dictionary_cache(Oid dictId)

{

  TSDictionaryCacheEntry *entry;

  if (TSDictionaryCacheHash == NULL)

  {

    /* First time through: initialize the hash table */

    HASHCTL   ctl;

    ctl.keysize = sizeof(Oid);

    ctl.entrysize = sizeof(TSDictionaryCacheEntry);

    TSDictionaryCacheHash = hash_create("Tsearch dictionary cache", 8,

                      &ctl, HASH_ELEM | HASH_BLOBS);

    /* Flush cache on pg_ts_dict and pg_ts_template changes */

    CacheRegisterSyscacheCallback(TSDICTOID, InvalidateTSCacheCallBack,

                    PointerGetDatum(TSDictionaryCacheHash));

    CacheRegisterSyscacheCallback(TSTEMPLATEOID, InvalidateTSCacheCallBack,

                    PointerGetDatum(TSDictionaryCacheHash));

    /* Also make sure CacheMemoryContext exists */

    if (!CacheMemoryContext)

      CreateCacheMemoryContext();

  }

  /* Check single-entry cache */

  if (lastUsedDictionary && lastUsedDictionary->dictId == dictId &&

    lastUsedDictionary->isvalid)

    return lastUsedDictionary;

  /* Try to look up an existing entry */

  entry = (TSDictionaryCacheEntry *) hash_search(TSDictionaryCacheHash,

                           &dictId,

                           HASH_FIND, NULL);

  if (entry == NULL || !entry->isvalid)

  {

    /*

     * If we didn't find one, we want to make one. But first look up the

     * object to be sure the OID is real.

     */

    HeapTuple tpdict,

          tptmpl;

    Form_pg_ts_dict dict;

    Form_pg_ts_template template;

    MemoryContext saveCtx;

    tpdict = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));

    if (!HeapTupleIsValid(tpdict))

      elog(ERROR, "cache lookup failed for text search dictionary %u",

         dictId);

    dict = (Form_pg_ts_dict) GETSTRUCT(tpdict);

    /*

     * Sanity checks

     */

    if (!OidIsValid(dict->dicttemplate))

      elog(ERROR, "text search dictionary %u has no template", dictId);

    /*

     * Retrieve dictionary's template

     */

    tptmpl = SearchSysCache1(TSTEMPLATEOID,

                 ObjectIdGetDatum(dict->dicttemplate));

    if (!HeapTupleIsValid(tptmpl))

      elog(ERROR, "cache lookup failed for text search template %u",

         dict->dicttemplate);

    template = (Form_pg_ts_template) GETSTRUCT(tptmpl);

    /*

     * Sanity checks

     */

    if (!OidIsValid(template->tmpllexize))

      elog(ERROR, "text search template %u has no lexize method",

         template->tmpllexize);

    /*

     * OK, create or clear out the hashtable entry

     */

    if (entry == NULL)

    {

      bool    found;

      entry = (TSDictionaryCacheEntry *)

        hash_search(TSDictionaryCacheHash,

              &dictId,

              HASH_ENTER, &found);

      Assert(!found);   /* it wasn't there a moment ago */

      memset(entry, 0, sizeof(TSDictionaryCacheEntry));

      entry->dictId = dictId;

      saveCtx = NULL;

    }

    else

    {

      saveCtx = entry->dictCtx; /* could be NULL if we failed before */

      memset(entry, 0, sizeof(TSDictionaryCacheEntry));

      entry->dictId = dictId;

      entry->dictCtx = saveCtx;

    }

    /*

     * Create or clear the entry's private memory context

     */

    if (saveCtx == NULL)

    {

      saveCtx = AllocSetContextCreate(CacheMemoryContext,

                      "TS dictionary",

                      ALLOCSET_SMALL_SIZES);

      entry->dictCtx = saveCtx;

      MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));

    }

    else

    {

      /* Don't let context's ident pointer dangle while we reset it */

      MemoryContextSetIdentifier(saveCtx, NULL);

      MemoryContextReset(saveCtx);

      MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));

    }

    entry->lexizeOid = template->tmpllexize;

    if (OidIsValid(template->tmplinit))

    {

      List     *dictoptions;

      Datum   opt;

      bool    isnull;

      MemoryContext oldcontext;

      /*

       * Init method runs in dictionary's private memory context, and we

       * make sure the options are stored there too.  This typically

       * results in a small amount of memory leakage, but it's not worth

       * complicating the API for tmplinit functions to avoid it.

       */

      oldcontext = MemoryContextSwitchTo(entry->dictCtx);

      opt = SysCacheGetAttr(TSDICTOID, tpdict,

                  Anum_pg_ts_dict_dictinitoption,

                  &isnull);

      if (isnull)

        dictoptions = NIL;

      else

        dictoptions = deserialize_deflist(opt);

      entry->dictData =

        DatumGetPointer(OidFunctionCall1(template->tmplinit,

                         PointerGetDatum(dictoptions)));

      MemoryContextSwitchTo(oldcontext);

    }

    ReleaseSysCache(tptmpl);

    ReleaseSysCache(tpdict);

    fmgr_info_cxt(entry->lexizeOid, &entry->lexize, entry->dictCtx);

    entry->isvalid = true;

  }

  lastUsedDictionary = entry;

  return entry;

}

/*

 * Initialize config cache and prepare callbacks.  This is split out of

 * lookup_ts_config_cache because we need to activate the callback before

 * caching TSCurrentConfigCache, too.

 */

static void

init_ts_config_cache(void)

{

  HASHCTL   ctl;

  ctl.keysize = sizeof(Oid);

  ctl.entrysize = sizeof(TSConfigCacheEntry);

  TSConfigCacheHash = hash_create("Tsearch configuration cache", 16,

                  &ctl, HASH_ELEM | HASH_BLOBS);

  /* Flush cache on pg_ts_config and pg_ts_config_map changes */

  CacheRegisterSyscacheCallback(TSCONFIGOID, InvalidateTSCacheCallBack,

                  PointerGetDatum(TSConfigCacheHash));

  CacheRegisterSyscacheCallback(TSCONFIGMAP, InvalidateTSCacheCallBack,

                  PointerGetDatum(TSConfigCacheHash));

  /* Also make sure CacheMemoryContext exists */

  if (!CacheMemoryContext)

    CreateCacheMemoryContext();

}

/*

 * Fetch configuration cache entry

 */

TSConfigCacheEntry *

lookup_ts_config_cache(Oid cfgId)

{

  TSConfigCacheEntry *entry;

  if (TSConfigCacheHash == NULL)

  {

    /* First time through: initialize the hash table */

    init_ts_config_cache();

  }

  /* Check single-entry cache */

  if (lastUsedConfig && lastUsedConfig->cfgId == cfgId &&

    lastUsedConfig->isvalid)

    return lastUsedConfig;

  /* Try to look up an existing entry */

  entry = (TSConfigCacheEntry *) hash_search(TSConfigCacheHash,

                         &cfgId,

                         HASH_FIND, NULL);

  if (entry == NULL || !entry->isvalid)

  {

    /*

     * If we didn't find one, we want to make one. But first look up the

     * object to be sure the OID is real.

     */

    HeapTuple tp;

    Form_pg_ts_config cfg;

    Relation  maprel;

    Relation  mapidx;

    ScanKeyData mapskey;

    SysScanDesc mapscan;

    HeapTuple maptup;

    ListDictionary maplists[MAXTOKENTYPE + 1];

    Oid     mapdicts[MAXDICTSPERTT];

    int     maxtokentype;

    int     ndicts;

    int     i;

    tp = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));

    if (!HeapTupleIsValid(tp))

      elog(ERROR, "cache lookup failed for text search configuration %u",

         cfgId);

    cfg = (Form_pg_ts_config) GETSTRUCT(tp);

    /*

     * Sanity checks

     */

    if (!OidIsValid(cfg->cfgparser))

      elog(ERROR, "text search configuration %u has no parser", cfgId);

    if (entry == NULL)

    {

      bool    found;

      /* Now make the cache entry */

      entry = (TSConfigCacheEntry *)

        hash_search(TSConfigCacheHash,

              &cfgId,

              HASH_ENTER, &found);

      Assert(!found);   /* it wasn't there a moment ago */

    }

    else

    {

      /* Cleanup old contents */

      if (entry->map)

      {

        for (i = 0; i < entry->lenmap; i++)

          if (entry->map[i].dictIds)

            pfree(entry->map[i].dictIds);

        pfree(entry->map);

      }

    }

    MemSet(entry, 0, sizeof(TSConfigCacheEntry));

    entry->cfgId = cfgId;

    entry->prsId = cfg->cfgparser;

    ReleaseSysCache(tp);

    /*

     * Scan pg_ts_config_map to gather dictionary list for each token type

     *

     * Because the index is on (mapcfg, maptokentype, mapseqno), we will

     * see the entries in maptokentype order, and in mapseqno order for

     * each token type, even though we didn't explicitly ask for that.

     */

    MemSet(maplists, 0, sizeof(maplists));

    maxtokentype = 0;

    ndicts = 0;

    ScanKeyInit(&mapskey,

          Anum_pg_ts_config_map_mapcfg,

          BTEqualStrategyNumber, F_OIDEQ,

          ObjectIdGetDatum(cfgId));

    maprel = table_open(TSConfigMapRelationId, AccessShareLock);

    mapidx = index_open(TSConfigMapIndexId, AccessShareLock);

    mapscan = systable_beginscan_ordered(maprel, mapidx,

                       NULL, 1, &mapskey);

    while ((maptup = systable_getnext_ordered(mapscan, ForwardScanDirection)) != NULL)

    {

      Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);

      int     toktype = cfgmap->maptokentype;

      if (toktype <= 0 || toktype > MAXTOKENTYPE)

        elog(ERROR, "maptokentype value %d is out of range", toktype);

      if (toktype < maxtokentype)

        elog(ERROR, "maptokentype entries are out of order");

      if (toktype > maxtokentype)

      {

        /* starting a new token type, but first save the prior data */

        if (ndicts > 0)

        {

          maplists[maxtokentype].len = ndicts;

          maplists[maxtokentype].dictIds = (Oid *)

            MemoryContextAlloc(CacheMemoryContext,

                       sizeof(Oid) * ndicts);

          memcpy(maplists[maxtokentype].dictIds, mapdicts,

               sizeof(Oid) * ndicts);

        }

        maxtokentype = toktype;

        mapdicts[0] = cfgmap->mapdict;

        ndicts = 1;

      }

      else

      {

        /* continuing data for current token type */

        if (ndicts >= MAXDICTSPERTT)

          elog(ERROR, "too many pg_ts_config_map entries for one token type");

        mapdicts[ndicts++] = cfgmap->mapdict;

      }

    }

    systable_endscan_ordered(mapscan);

    index_close(mapidx, AccessShareLock);

    table_close(maprel, AccessShareLock);

    if (ndicts > 0)

    {

      /* save the last token type's dictionaries */

      maplists[maxtokentype].len = ndicts;

      maplists[maxtokentype].dictIds = (Oid *)

        MemoryContextAlloc(CacheMemoryContext,

                   sizeof(Oid) * ndicts);

      memcpy(maplists[maxtokentype].dictIds, mapdicts,

           sizeof(Oid) * ndicts);

      /* and save the overall map */

      entry->lenmap = maxtokentype + 1;

      entry->map = (ListDictionary *)

        MemoryContextAlloc(CacheMemoryContext,

                   sizeof(ListDictionary) * entry->lenmap);

      memcpy(entry->map, maplists,

           sizeof(ListDictionary) * entry->lenmap);

    }

    entry->isvalid = true;

  }

  lastUsedConfig = entry;

  return entry;

}

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

 * GUC variable "default_text_search_config"

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

 */

Oid

getTSCurrentConfig(bool emitError)

{

  List     *namelist;

  /* if we have a cached value, return it */

  if (OidIsValid(TSCurrentConfigCache))

    return TSCurrentConfigCache;

  /* fail if GUC hasn't been set up yet */

  if (TSCurrentConfig == NULL || *TSCurrentConfig == '\0')

  {

    if (emitError)

      elog(ERROR, "text search configuration isn't set");

    else

      return InvalidOid;

  }

  if (TSConfigCacheHash == NULL)

  {

    /* First time through: initialize the tsconfig inval callback */

    init_ts_config_cache();

  }

  /* Look up the config */

  if (emitError)

  {

    namelist = stringToQualifiedNameList(TSCurrentConfig, NULL);

    TSCurrentConfigCache = get_ts_config_oid(namelist, false);

  }

  else

  {

    ErrorSaveContext escontext = {T_ErrorSaveContext};

    namelist = stringToQualifiedNameList(TSCurrentConfig,

                       (Node *) &escontext);

    if (namelist != NIL)

      TSCurrentConfigCache = get_ts_config_oid(namelist, true);

    else

      TSCurrentConfigCache = InvalidOid; /* bad name list syntax */

  }

  return TSCurrentConfigCache;

}

/* GUC check_hook for default_text_search_config */

bool

check_default_text_search_config(char **newval, void **extra, GucSource source)

{

  /*

   * If we aren't inside a transaction, or connected to a database, we

   * cannot do the catalog accesses necessary to verify the config name.

   * Must accept it on faith.

   */

  if (IsTransactionState() && MyDatabaseId != InvalidOid)

  {

    ErrorSaveContext escontext = {T_ErrorSaveContext};

    List     *namelist;

    Oid     cfgId;

    HeapTuple tuple;

    Form_pg_ts_config cfg;

    char     *buf;

    namelist = stringToQualifiedNameList(*newval,

                       (Node *) &escontext);

    if (namelist != NIL)

      cfgId = get_ts_config_oid(namelist, true);

    else

      cfgId = InvalidOid; /* bad name list syntax */

    /*

     * When source == PGC_S_TEST, don't throw a hard error for a

     * nonexistent configuration, only a NOTICE.  See comments in guc.h.

     */

    if (!OidIsValid(cfgId))

    {

      if (source == PGC_S_TEST)

      {

        ereport(NOTICE,

            (errcode(ERRCODE_UNDEFINED_OBJECT),

             errmsg("text search configuration \"%s\" does not exist", *newval)));

        return true;

      }

      else

        return false;

    }

    /*

     * Modify the actually stored value to be fully qualified, to ensure

     * later changes of search_path don't affect it.

     */

    tuple = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));

    if (!HeapTupleIsValid(tuple))

      elog(ERROR, "cache lookup failed for text search configuration %u",

         cfgId);

    cfg = (Form_pg_ts_config) GETSTRUCT(tuple);

    buf = quote_qualified_identifier(get_namespace_name(cfg->cfgnamespace),

                     NameStr(cfg->cfgname));

    ReleaseSysCache(tuple);

    /* GUC wants it guc_malloc'd not palloc'd */

    guc_free(*newval);

    *newval = guc_strdup(LOG, buf);

    pfree(buf);

    if (!*newval)

      return false;

  }

  return true;

}

/* GUC assign_hook for default_text_search_config */

void

assign_default_text_search_config(const char *newval, void *extra)

{

  /* Just reset the cache to force a lookup on first use */

  TSCurrentConfigCache = InvalidOid;

}