PostgreSQL Source Code  git master
ts_cache.h File Reference
#include "fmgr.h"
Include dependency graph for ts_cache.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of 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

TSParserCacheEntrylookup_ts_parser_cache (Oid prsId)
 
TSDictionaryCacheEntrylookup_ts_dictionary_cache (Oid dictId)
 
TSConfigCacheEntrylookup_ts_config_cache (Oid cfgId)
 
Oid getTSCurrentConfig (bool emitError)
 

Variables

PGDLLIMPORT char * TSCurrentConfig
 

Typedef Documentation

◆ TSAnyCacheEntry

◆ TSDictionaryCacheEntry

◆ TSParserCacheEntry

Function Documentation

◆ getTSCurrentConfig()

Oid getTSCurrentConfig ( bool  emitError)

Definition at line 556 of file ts_cache.c.

557 {
558  List *namelist;
559 
560  /* if we have a cached value, return it */
562  return TSCurrentConfigCache;
563 
564  /* fail if GUC hasn't been set up yet */
565  if (TSCurrentConfig == NULL || *TSCurrentConfig == '\0')
566  {
567  if (emitError)
568  elog(ERROR, "text search configuration isn't set");
569  else
570  return InvalidOid;
571  }
572 
573  if (TSConfigCacheHash == NULL)
574  {
575  /* First time through: initialize the tsconfig inval callback */
577  }
578 
579  /* Look up the config */
580  if (emitError)
581  {
582  namelist = stringToQualifiedNameList(TSCurrentConfig, NULL);
583  TSCurrentConfigCache = get_ts_config_oid(namelist, false);
584  }
585  else
586  {
587  ErrorSaveContext escontext = {T_ErrorSaveContext};
588 
590  (Node *) &escontext);
591  if (namelist != NIL)
592  TSCurrentConfigCache = get_ts_config_oid(namelist, true);
593  else
594  TSCurrentConfigCache = InvalidOid; /* bad name list syntax */
595  }
596 
597  return TSCurrentConfigCache;
598 }
#define OidIsValid(objectId)
Definition: c.h:764
#define ERROR
Definition: elog.h:39
Oid get_ts_config_oid(List *names, bool missing_ok)
Definition: namespace.c:3119
#define NIL
Definition: pg_list.h:68
#define InvalidOid
Definition: postgres_ext.h:36
List * stringToQualifiedNameList(const char *string, Node *escontext)
Definition: regproc.c:1777
Definition: pg_list.h:54
Definition: nodes.h:129
static void init_ts_config_cache(void)
Definition: ts_cache.c:362
static HTAB * TSConfigCacheHash
Definition: ts_cache.c:70
char * TSCurrentConfig
Definition: ts_cache.c:76
static Oid TSCurrentConfigCache
Definition: ts_cache.c:78

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.

386 {
387  TSConfigCacheEntry *entry;
388 
389  if (TSConfigCacheHash == NULL)
390  {
391  /* First time through: initialize the hash table */
393  }
394 
395  /* Check single-entry cache */
396  if (lastUsedConfig && lastUsedConfig->cfgId == cfgId &&
398  return lastUsedConfig;
399 
400  /* Try to look up an existing entry */
402  &cfgId,
403  HASH_FIND, NULL);
404  if (entry == NULL || !entry->isvalid)
405  {
406  /*
407  * If we didn't find one, we want to make one. But first look up the
408  * object to be sure the OID is real.
409  */
410  HeapTuple tp;
411  Form_pg_ts_config cfg;
412  Relation maprel;
413  Relation mapidx;
414  ScanKeyData mapskey;
415  SysScanDesc mapscan;
416  HeapTuple maptup;
417  ListDictionary maplists[MAXTOKENTYPE + 1];
418  Oid mapdicts[MAXDICTSPERTT];
419  int maxtokentype;
420  int ndicts;
421  int i;
422 
424  if (!HeapTupleIsValid(tp))
425  elog(ERROR, "cache lookup failed for text search configuration %u",
426  cfgId);
427  cfg = (Form_pg_ts_config) GETSTRUCT(tp);
428 
429  /*
430  * Sanity checks
431  */
432  if (!OidIsValid(cfg->cfgparser))
433  elog(ERROR, "text search configuration %u has no parser", cfgId);
434 
435  if (entry == NULL)
436  {
437  bool found;
438 
439  /* Now make the cache entry */
440  entry = (TSConfigCacheEntry *)
442  &cfgId,
443  HASH_ENTER, &found);
444  Assert(!found); /* it wasn't there a moment ago */
445  }
446  else
447  {
448  /* Cleanup old contents */
449  if (entry->map)
450  {
451  for (i = 0; i < entry->lenmap; i++)
452  if (entry->map[i].dictIds)
453  pfree(entry->map[i].dictIds);
454  pfree(entry->map);
455  }
456  }
457 
458  MemSet(entry, 0, sizeof(TSConfigCacheEntry));
459  entry->cfgId = cfgId;
460  entry->prsId = cfg->cfgparser;
461 
462  ReleaseSysCache(tp);
463 
464  /*
465  * Scan pg_ts_config_map to gather dictionary list for each token type
466  *
467  * Because the index is on (mapcfg, maptokentype, mapseqno), we will
468  * see the entries in maptokentype order, and in mapseqno order for
469  * each token type, even though we didn't explicitly ask for that.
470  */
471  MemSet(maplists, 0, sizeof(maplists));
472  maxtokentype = 0;
473  ndicts = 0;
474 
475  ScanKeyInit(&mapskey,
476  Anum_pg_ts_config_map_mapcfg,
477  BTEqualStrategyNumber, F_OIDEQ,
478  ObjectIdGetDatum(cfgId));
479 
480  maprel = table_open(TSConfigMapRelationId, AccessShareLock);
481  mapidx = index_open(TSConfigMapIndexId, AccessShareLock);
482  mapscan = systable_beginscan_ordered(maprel, mapidx,
483  NULL, 1, &mapskey);
484 
485  while ((maptup = systable_getnext_ordered(mapscan, ForwardScanDirection)) != NULL)
486  {
488  int toktype = cfgmap->maptokentype;
489 
490  if (toktype <= 0 || toktype > MAXTOKENTYPE)
491  elog(ERROR, "maptokentype value %d is out of range", toktype);
492  if (toktype < maxtokentype)
493  elog(ERROR, "maptokentype entries are out of order");
494  if (toktype > maxtokentype)
495  {
496  /* starting a new token type, but first save the prior data */
497  if (ndicts > 0)
498  {
499  maplists[maxtokentype].len = ndicts;
500  maplists[maxtokentype].dictIds = (Oid *)
502  sizeof(Oid) * ndicts);
503  memcpy(maplists[maxtokentype].dictIds, mapdicts,
504  sizeof(Oid) * ndicts);
505  }
506  maxtokentype = toktype;
507  mapdicts[0] = cfgmap->mapdict;
508  ndicts = 1;
509  }
510  else
511  {
512  /* continuing data for current token type */
513  if (ndicts >= MAXDICTSPERTT)
514  elog(ERROR, "too many pg_ts_config_map entries for one token type");
515  mapdicts[ndicts++] = cfgmap->mapdict;
516  }
517  }
518 
519  systable_endscan_ordered(mapscan);
520  index_close(mapidx, AccessShareLock);
521  table_close(maprel, AccessShareLock);
522 
523  if (ndicts > 0)
524  {
525  /* save the last token type's dictionaries */
526  maplists[maxtokentype].len = ndicts;
527  maplists[maxtokentype].dictIds = (Oid *)
529  sizeof(Oid) * ndicts);
530  memcpy(maplists[maxtokentype].dictIds, mapdicts,
531  sizeof(Oid) * ndicts);
532  /* and save the overall map */
533  entry->lenmap = maxtokentype + 1;
534  entry->map = (ListDictionary *)
536  sizeof(ListDictionary) * entry->lenmap);
537  memcpy(entry->map, maplists,
538  sizeof(ListDictionary) * entry->lenmap);
539  }
540 
541  entry->isvalid = true;
542  }
543 
544  lastUsedConfig = entry;
545 
546  return entry;
547 }
#define MemSet(start, val, len)
Definition: c.h:1009
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:953
SysScanDesc systable_beginscan_ordered(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, ScanKey key)
Definition: genam.c:646
void systable_endscan_ordered(SysScanDesc sysscan)
Definition: genam.c:736
HeapTuple systable_getnext_ordered(SysScanDesc sysscan, ScanDirection direction)
Definition: genam.c:711
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_ENTER
Definition: hsearch.h:114
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
void index_close(Relation relation, LOCKMODE lockmode)
Definition: indexam.c:158
Relation index_open(Oid relationId, LOCKMODE lockmode)
Definition: indexam.c:132
int i
Definition: isn.c:73
Assert(fmt[strlen(fmt) - 1] !='\n')
#define AccessShareLock
Definition: lockdefs.h:36
void pfree(void *pointer)
Definition: mcxt.c:1456
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1021
MemoryContext CacheMemoryContext
Definition: mcxt.c:144
FormData_pg_ts_config * Form_pg_ts_config
Definition: pg_ts_config.h:48
FormData_pg_ts_config_map * Form_pg_ts_config_map
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
unsigned int Oid
Definition: postgres_ext.h:31
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
Definition: scankey.c:76
@ ForwardScanDirection
Definition: sdir.h:28
#define BTEqualStrategyNumber
Definition: stratnum.h:31
Oid * dictIds
Definition: ts_cache.h:68
ListDictionary * map
Definition: ts_cache.h:80
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:868
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:820
@ TSCONFIGOID
Definition: syscache.h:106
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
#define MAXTOKENTYPE
Definition: ts_cache.c:60
#define MAXDICTSPERTT
Definition: ts_cache.c:61
static TSConfigCacheEntry * lastUsedConfig
Definition: ts_cache.c:71

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(), TSConfigCacheHash, and TSCONFIGOID.

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.

209 {
210  TSDictionaryCacheEntry *entry;
211 
212  if (TSDictionaryCacheHash == NULL)
213  {
214  /* First time through: initialize the hash table */
215  HASHCTL ctl;
216 
217  ctl.keysize = sizeof(Oid);
218  ctl.entrysize = sizeof(TSDictionaryCacheEntry);
219  TSDictionaryCacheHash = hash_create("Tsearch dictionary cache", 8,
220  &ctl, HASH_ELEM | HASH_BLOBS);
221  /* Flush cache on pg_ts_dict and pg_ts_template changes */
226 
227  /* Also make sure CacheMemoryContext exists */
228  if (!CacheMemoryContext)
230  }
231 
232  /* Check single-entry cache */
233  if (lastUsedDictionary && lastUsedDictionary->dictId == dictId &&
235  return lastUsedDictionary;
236 
237  /* Try to look up an existing entry */
239  &dictId,
240  HASH_FIND, NULL);
241  if (entry == NULL || !entry->isvalid)
242  {
243  /*
244  * If we didn't find one, we want to make one. But first look up the
245  * object to be sure the OID is real.
246  */
247  HeapTuple tpdict,
248  tptmpl;
249  Form_pg_ts_dict dict;
250  Form_pg_ts_template template;
251  MemoryContext saveCtx;
252 
253  tpdict = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));
254  if (!HeapTupleIsValid(tpdict))
255  elog(ERROR, "cache lookup failed for text search dictionary %u",
256  dictId);
257  dict = (Form_pg_ts_dict) GETSTRUCT(tpdict);
258 
259  /*
260  * Sanity checks
261  */
262  if (!OidIsValid(dict->dicttemplate))
263  elog(ERROR, "text search dictionary %u has no template", dictId);
264 
265  /*
266  * Retrieve dictionary's template
267  */
269  ObjectIdGetDatum(dict->dicttemplate));
270  if (!HeapTupleIsValid(tptmpl))
271  elog(ERROR, "cache lookup failed for text search template %u",
272  dict->dicttemplate);
273  template = (Form_pg_ts_template) GETSTRUCT(tptmpl);
274 
275  /*
276  * Sanity checks
277  */
278  if (!OidIsValid(template->tmpllexize))
279  elog(ERROR, "text search template %u has no lexize method",
280  template->tmpllexize);
281 
282  if (entry == NULL)
283  {
284  bool found;
285 
286  /* Now make the cache entry */
287  entry = (TSDictionaryCacheEntry *)
289  &dictId,
290  HASH_ENTER, &found);
291  Assert(!found); /* it wasn't there a moment ago */
292 
293  /* Create private memory context the first time through */
295  "TS dictionary",
297  MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));
298  }
299  else
300  {
301  /* Clear the existing entry's private context */
302  saveCtx = entry->dictCtx;
303  /* Don't let context's ident pointer dangle while we reset it */
304  MemoryContextSetIdentifier(saveCtx, NULL);
305  MemoryContextReset(saveCtx);
306  MemoryContextCopyAndSetIdentifier(saveCtx, NameStr(dict->dictname));
307  }
308 
309  MemSet(entry, 0, sizeof(TSDictionaryCacheEntry));
310  entry->dictId = dictId;
311  entry->dictCtx = saveCtx;
312 
313  entry->lexizeOid = template->tmpllexize;
314 
315  if (OidIsValid(template->tmplinit))
316  {
317  List *dictoptions;
318  Datum opt;
319  bool isnull;
320  MemoryContext oldcontext;
321 
322  /*
323  * Init method runs in dictionary's private memory context, and we
324  * make sure the options are stored there too
325  */
326  oldcontext = MemoryContextSwitchTo(entry->dictCtx);
327 
328  opt = SysCacheGetAttr(TSDICTOID, tpdict,
329  Anum_pg_ts_dict_dictinitoption,
330  &isnull);
331  if (isnull)
332  dictoptions = NIL;
333  else
334  dictoptions = deserialize_deflist(opt);
335 
336  entry->dictData =
337  DatumGetPointer(OidFunctionCall1(template->tmplinit,
338  PointerGetDatum(dictoptions)));
339 
340  MemoryContextSwitchTo(oldcontext);
341  }
342 
343  ReleaseSysCache(tptmpl);
344  ReleaseSysCache(tpdict);
345 
346  fmgr_info_cxt(entry->lexizeOid, &entry->lexize, entry->dictCtx);
347 
348  entry->isvalid = true;
349  }
350 
351  lastUsedDictionary = entry;
352 
353  return entry;
354 }
#define NameStr(name)
Definition: c.h:735
void CreateCacheMemoryContext(void)
Definition: catcache.c:667
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:350
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
#define OidFunctionCall1(functionId, arg1)
Definition: fmgr.h:680
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
Definition: inval.c:1518
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:330
void MemoryContextSetIdentifier(MemoryContext context, const char *id)
Definition: mcxt.c:521
#define AllocSetContextCreate
Definition: memutils.h:126
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:160
#define MemoryContextCopyAndSetIdentifier(cxt, id)
Definition: memutils.h:98
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:138
FormData_pg_ts_dict * Form_pg_ts_dict
Definition: pg_ts_dict.h:52
FormData_pg_ts_template * Form_pg_ts_template
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
MemoryContext dictCtx
Definition: ts_cache.h:61
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
Definition: syscache.c:1081
@ TSTEMPLATEOID
Definition: syscache.h:112
@ TSDICTOID
Definition: syscache.h:108
static TSDictionaryCacheEntry * lastUsedDictionary
Definition: ts_cache.c:68
static void InvalidateTSCacheCallBack(Datum arg, int cacheid, uint32 hashvalue)
Definition: ts_cache.c:94
static HTAB * TSDictionaryCacheHash
Definition: ts_cache.c:67
struct TSDictionaryCacheEntry TSDictionaryCacheEntry
List * deserialize_deflist(Datum txt)
Definition: tsearchcmds.c:1584

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

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.

114 {
115  TSParserCacheEntry *entry;
116 
117  if (TSParserCacheHash == NULL)
118  {
119  /* First time through: initialize the hash table */
120  HASHCTL ctl;
121 
122  ctl.keysize = sizeof(Oid);
123  ctl.entrysize = sizeof(TSParserCacheEntry);
124  TSParserCacheHash = hash_create("Tsearch parser cache", 4,
125  &ctl, HASH_ELEM | HASH_BLOBS);
126  /* Flush cache on pg_ts_parser changes */
129 
130  /* Also make sure CacheMemoryContext exists */
131  if (!CacheMemoryContext)
133  }
134 
135  /* Check single-entry cache */
136  if (lastUsedParser && lastUsedParser->prsId == prsId &&
138  return lastUsedParser;
139 
140  /* Try to look up an existing entry */
142  &prsId,
143  HASH_FIND, NULL);
144  if (entry == NULL || !entry->isvalid)
145  {
146  /*
147  * If we didn't find one, we want to make one. But first look up the
148  * object to be sure the OID is real.
149  */
150  HeapTuple tp;
151  Form_pg_ts_parser prs;
152 
154  if (!HeapTupleIsValid(tp))
155  elog(ERROR, "cache lookup failed for text search parser %u",
156  prsId);
157  prs = (Form_pg_ts_parser) GETSTRUCT(tp);
158 
159  /*
160  * Sanity checks
161  */
162  if (!OidIsValid(prs->prsstart))
163  elog(ERROR, "text search parser %u has no prsstart method", prsId);
164  if (!OidIsValid(prs->prstoken))
165  elog(ERROR, "text search parser %u has no prstoken method", prsId);
166  if (!OidIsValid(prs->prsend))
167  elog(ERROR, "text search parser %u has no prsend method", prsId);
168 
169  if (entry == NULL)
170  {
171  bool found;
172 
173  /* Now make the cache entry */
174  entry = (TSParserCacheEntry *)
175  hash_search(TSParserCacheHash, &prsId, HASH_ENTER, &found);
176  Assert(!found); /* it wasn't there a moment ago */
177  }
178 
179  MemSet(entry, 0, sizeof(TSParserCacheEntry));
180  entry->prsId = prsId;
181  entry->startOid = prs->prsstart;
182  entry->tokenOid = prs->prstoken;
183  entry->endOid = prs->prsend;
184  entry->headlineOid = prs->prsheadline;
185  entry->lextypeOid = prs->prslextype;
186 
187  ReleaseSysCache(tp);
188 
191  fmgr_info_cxt(entry->endOid, &entry->prsend, CacheMemoryContext);
192  if (OidIsValid(entry->headlineOid))
193  fmgr_info_cxt(entry->headlineOid, &entry->prsheadline,
195 
196  entry->isvalid = true;
197  }
198 
199  lastUsedParser = entry;
200 
201  return entry;
202 }
FormData_pg_ts_parser * Form_pg_ts_parser
Definition: pg_ts_parser.h:55
FmgrInfo prstoken
Definition: ts_cache.h:46
FmgrInfo prsstart
Definition: ts_cache.h:45
FmgrInfo prsheadline
Definition: ts_cache.h:48
FmgrInfo prsend
Definition: ts_cache.h:47
@ TSPARSEROID
Definition: syscache.h:110
static TSParserCacheEntry * lastUsedParser
Definition: ts_cache.c:65
static HTAB * TSParserCacheHash
Definition: ts_cache.c:64
struct TSParserCacheEntry TSParserCacheEntry

References Assert(), CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), elog(), TSParserCacheEntry::endOid, HASHCTL::entrysize, ERROR, fmgr_info_cxt(), GETSTRUCT, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FIND, hash_search(), TSParserCacheEntry::headlineOid, HeapTupleIsValid, InvalidateTSCacheCallBack(), TSParserCacheEntry::isvalid, HASHCTL::keysize, lastUsedParser, TSParserCacheEntry::lextypeOid, MemSet, ObjectIdGetDatum(), OidIsValid, PointerGetDatum(), TSParserCacheEntry::prsend, TSParserCacheEntry::prsheadline, TSParserCacheEntry::prsId, TSParserCacheEntry::prsstart, TSParserCacheEntry::prstoken, ReleaseSysCache(), SearchSysCache1(), TSParserCacheEntry::startOid, TSParserCacheEntry::tokenOid, TSParserCacheHash, and TSPARSEROID.

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().