#include "fmgr.h"

Include dependency graph for ts_cache.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	TSAnyCacheEntry

struct	TSParserCacheEntry

struct	TSDictionaryCacheEntry

struct	ListDictionary

struct	TSConfigCacheEntry

Typedefs
typedef struct TSAnyCacheEntry	TSAnyCacheEntry

typedef struct TSParserCacheEntry	TSParserCacheEntry

typedef struct TSDictionaryCacheEntry	TSDictionaryCacheEntry

Functions
TSParserCacheEntry *	lookup_ts_parser_cache (Oid prsId)

TSDictionaryCacheEntry *	lookup_ts_dictionary_cache (Oid dictId)

TSConfigCacheEntry *	lookup_ts_config_cache (Oid cfgId)

Oid	getTSCurrentConfig (bool emitError)

Variables
PGDLLIMPORT char *	TSCurrentConfig

Typedef Documentation

◆ TSAnyCacheEntry

typedef struct TSAnyCacheEntry TSAnyCacheEntry

◆ TSDictionaryCacheEntry

typedef struct TSDictionaryCacheEntry TSDictionaryCacheEntry

◆ TSParserCacheEntry

typedef struct TSParserCacheEntry TSParserCacheEntry

Function Documentation

◆ getTSCurrentConfig()

Oid getTSCurrentConfig ( bool emitError )

Definition at line 556 of file ts_cache.c.

 {
     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;
 }

References elog, ERROR, get_ts_config_oid(), init_ts_config_cache(), InvalidOid, NIL, OidIsValid, stringToQualifiedNameList(), TSConfigCacheHash, TSCurrentConfig, and TSCurrentConfigCache.

Referenced by get_current_ts_config(), json_string_to_tsvector(), json_to_tsvector(), jsonb_string_to_tsvector(), jsonb_to_tsvector(), phraseto_tsquery(), plainto_tsquery(), to_tsquery(), to_tsvector(), ts_headline(), ts_headline_json(), ts_headline_json_opt(), ts_headline_jsonb(), ts_headline_jsonb_opt(), ts_headline_opt(), and websearch_to_tsquery().

◆ lookup_ts_config_cache()

TSConfigCacheEntry* lookup_ts_config_cache ( Oid cfgId )

Definition at line 385 of file ts_cache.c.

 {
     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;
 }

References AccessShareLock, Assert, BTEqualStrategyNumber, CacheMemoryContext, TSConfigCacheEntry::cfgId, ListDictionary::dictIds, elog, ERROR, ForwardScanDirection, GETSTRUCT, HASH_ENTER, HASH_FIND, hash_search(), HeapTupleIsValid, i, index_close(), index_open(), init_ts_config_cache(), TSConfigCacheEntry::isvalid, lastUsedConfig, ListDictionary::len, TSConfigCacheEntry::lenmap, TSConfigCacheEntry::map, MAXDICTSPERTT, MAXTOKENTYPE, MemoryContextAlloc(), MemSet, ObjectIdGetDatum(), OidIsValid, pfree(), TSConfigCacheEntry::prsId, ReleaseSysCache(), ScanKeyInit(), SearchSysCache1(), systable_beginscan_ordered(), systable_endscan_ordered(), systable_getnext_ordered(), table_close(), table_open(), and TSConfigCacheHash.

Referenced by hlparsetext(), parsetext(), ts_headline_byid_opt(), ts_headline_json_byid_opt(), and ts_headline_jsonb_byid_opt().

◆ lookup_ts_dictionary_cache()

TSDictionaryCacheEntry* lookup_ts_dictionary_cache ( Oid dictId )

Definition at line 208 of file ts_cache.c.

 {
     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);
  
         if (entry == NULL)
         {
             bool        found;
  
             /* Now make the cache entry */
             entry = (TSDictionaryCacheEntry *)
                 hash_search(TSDictionaryCacheHash,
                             &dictId,
                             HASH_ENTER, &found);
             Assert(!found);     /* it wasn't there a moment ago */
  
             /* Create private memory context the first time through */
             saveCtx = AllocSetContextCreate(CacheMemoryContext,
                                             "TS dictionary",
                                             ALLOCSET_SMALL_SIZES);
             MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));
         }
         else
         {
             /* Clear the existing entry's private context */
             saveCtx = entry->dictCtx;
             /* Don't let context's ident pointer dangle while we reset it */
             MemoryContextSetIdentifier(saveCtx, NULL);
             MemoryContextReset(saveCtx);
             MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));
         }
  
         MemSet(entry, 0, sizeof(TSDictionaryCacheEntry));
         entry->dictId = dictId;
         entry->dictCtx = saveCtx;
  
         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
              */
             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;
 }

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), ctl, DatumGetPointer(), deserialize_deflist(), TSDictionaryCacheEntry::dictCtx, TSDictionaryCacheEntry::dictData, TSDictionaryCacheEntry::dictId, elog, ERROR, fmgr_info_cxt(), GETSTRUCT, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FIND, hash_search(), HeapTupleIsValid, InvalidateTSCacheCallBack(), TSDictionaryCacheEntry::isvalid, lastUsedDictionary, TSDictionaryCacheEntry::lexize, TSDictionaryCacheEntry::lexizeOid, MemoryContextCopyAndSetIdentifier, MemoryContextReset(), MemoryContextSetIdentifier(), MemoryContextSwitchTo(), MemSet, NameStr, NIL, ObjectIdGetDatum(), OidFunctionCall1, OidIsValid, PointerGetDatum(), ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttr(), and TSDictionaryCacheHash.

Referenced by LexizeExec(), thesaurus_init(), thesaurus_lexize(), ts_lexize(), and unaccent_dict().

◆ lookup_ts_parser_cache()

TSParserCacheEntry* lookup_ts_parser_cache ( Oid prsId )

Definition at line 113 of file ts_cache.c.

 {
     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;
 }

Referenced by getTokenTypes(), hlparsetext(), parsetext(), prs_setup_firstcall(), ts_headline_byid_opt(), ts_headline_json_byid_opt(), ts_headline_jsonb_byid_opt(), and tt_setup_firstcall().

Variable Documentation

◆ TSCurrentConfig

PGDLLIMPORT char* TSCurrentConfig

extern

Definition at line 76 of file ts_cache.c.

Referenced by getTSCurrentConfig().

Data Structures

Typedefs

Functions

Variables