#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/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/regproc.h"
#include "utils/syscache.h"

Include dependency graph for ts_cache.c:

Macros
#define	MAXTOKENTYPE 256

#define	MAXDICTSPERTT 100

Functions
static void	InvalidateTSCacheCallBack (Datum arg, int cacheid, uint32 hashvalue)

TSParserCacheEntry *	lookup_ts_parser_cache (Oid prsId)

TSDictionaryCacheEntry *	lookup_ts_dictionary_cache (Oid dictId)

static void	init_ts_config_cache (void)

TSConfigCacheEntry *	lookup_ts_config_cache (Oid cfgId)

Oid	getTSCurrentConfig (bool emitError)

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

void	assign_default_text_search_config (const char newval, void extra)

Variables
static HTAB *	TSParserCacheHash = NULL

static TSParserCacheEntry *	lastUsedParser = NULL

static HTAB *	TSDictionaryCacheHash = NULL

static TSDictionaryCacheEntry *	lastUsedDictionary = NULL

static HTAB *	TSConfigCacheHash = NULL

static TSConfigCacheEntry *	lastUsedConfig = NULL

char *	TSCurrentConfig = NULL

static Oid	TSCurrentConfigCache = InvalidOid

Macro Definition Documentation

◆ MAXDICTSPERTT

#define MAXDICTSPERTT 100

Definition at line 61 of file ts_cache.c.

◆ MAXTOKENTYPE

#define MAXTOKENTYPE 256

Definition at line 60 of file ts_cache.c.

Function Documentation

◆ assign_default_text_search_config()

void assign_default_text_search_config	(	const char *	newval,
		void *	extra
	)

Definition at line 672 of file ts_cache.c.

{
    /* Just reset the cache to force a lookup on first use */
    TSCurrentConfigCache = InvalidOid;
}

References InvalidOid, and TSCurrentConfigCache.

◆ check_default_text_search_config()

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

Definition at line 604 of file ts_cache.c.

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

References buf, elog, ereport, errcode(), errmsg(), ERROR, get_namespace_name(), get_ts_config_oid(), GETSTRUCT(), guc_free(), guc_strdup(), HeapTupleIsValid, InvalidOid, IsTransactionState(), LOG, MyDatabaseId, NameStr, newval, NIL, NOTICE, ObjectIdGetDatum(), OidIsValid, pfree(), PGC_S_TEST, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), source, and stringToQualifiedNameList().

◆ getTSCurrentConfig()

Oid getTSCurrentConfig ( bool emitError )

Definition at line 558 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().

◆ init_ts_config_cache()

static void init_ts_config_cache ( void )

static

Definition at line 364 of file ts_cache.c.

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

References CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), ctl, HASH_BLOBS, hash_create(), HASH_ELEM, InvalidateTSCacheCallBack(), PointerGetDatum(), and TSConfigCacheHash.

Referenced by getTSCurrentConfig(), and lookup_ts_config_cache().

◆ InvalidateTSCacheCallBack()

static void InvalidateTSCacheCallBack	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 94 of file ts_cache.c.

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

References arg, DatumGetPointer(), hash(), hash_seq_init(), hash_seq_search(), InvalidOid, TSAnyCacheEntry::isvalid, TSConfigCacheHash, and TSCurrentConfigCache.

Referenced by init_ts_config_cache(), lookup_ts_dictionary_cache(), and lookup_ts_parser_cache().

◆ lookup_ts_config_cache()

TSConfigCacheEntry * lookup_ts_config_cache ( Oid cfgId )

Definition at line 387 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.  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;
}

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

◆ lastUsedConfig

TSConfigCacheEntry* lastUsedConfig = NULL

static

Definition at line 71 of file ts_cache.c.

Referenced by lookup_ts_config_cache().

◆ lastUsedDictionary

TSDictionaryCacheEntry* lastUsedDictionary = NULL

static

Definition at line 68 of file ts_cache.c.

Referenced by lookup_ts_dictionary_cache().

◆ lastUsedParser

TSParserCacheEntry* lastUsedParser = NULL

static

Definition at line 65 of file ts_cache.c.

Referenced by lookup_ts_parser_cache().

◆ TSConfigCacheHash

HTAB* TSConfigCacheHash = NULL

static

Definition at line 70 of file ts_cache.c.

Referenced by getTSCurrentConfig(), init_ts_config_cache(), InvalidateTSCacheCallBack(), and lookup_ts_config_cache().

◆ TSCurrentConfig

char* TSCurrentConfig = NULL

Definition at line 76 of file ts_cache.c.

Referenced by getTSCurrentConfig().

◆ TSCurrentConfigCache

Oid TSCurrentConfigCache = InvalidOid

static

Definition at line 78 of file ts_cache.c.

Referenced by assign_default_text_search_config(), getTSCurrentConfig(), and InvalidateTSCacheCallBack().

◆ TSDictionaryCacheHash

HTAB* TSDictionaryCacheHash = NULL

static

Definition at line 67 of file ts_cache.c.

Referenced by lookup_ts_dictionary_cache().

◆ TSParserCacheHash

HTAB* TSParserCacheHash = NULL

static

Definition at line 64 of file ts_cache.c.

Referenced by lookup_ts_parser_cache().

Macros

Functions

Variables

Macro Definition Documentation

◆ MAXDICTSPERTT

◆ MAXTOKENTYPE

Function Documentation

◆ assign_default_text_search_config()

◆ check_default_text_search_config()

◆ getTSCurrentConfig()

◆ init_ts_config_cache()

◆ InvalidateTSCacheCallBack()

◆ lookup_ts_config_cache()

◆ lookup_ts_dictionary_cache()

◆ lookup_ts_parser_cache()

Variable Documentation

◆ lastUsedConfig

◆ lastUsedDictionary

◆ lastUsedParser

◆ TSConfigCacheHash

◆ TSCurrentConfig

◆ TSCurrentConfigCache

◆ TSDictionaryCacheHash

◆ TSParserCacheHash