syscache.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * syscache.h
 *    System catalog cache definitions.
 *
 * See also lsyscache.h, which provides convenience routines for
 * common cache-lookup operations.
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/utils/syscache.h
 *
 *-------------------------------------------------------------------------
 */
#ifndef SYSCACHE_H
#define SYSCACHE_H
 
#include "access/attnum.h"
#include "access/htup.h"
/* we intentionally do not include utils/catcache.h here */
 
#include "catalog/syscache_ids.h"   /* IWYU pragma: export */
 
extern void InitCatalogCache(void);
extern void InitCatalogCachePhase2(void);
 
extern HeapTuple SearchSysCache(SysCacheIdentifier cacheId,
                                Datum key1, Datum key2, Datum key3, Datum key4);
 
/*
 * The use of argument specific numbers is encouraged. They're faster, and
 * insulates the caller from changes in the maximum number of keys.
 */
extern HeapTuple SearchSysCache1(SysCacheIdentifier cacheId,
                                 Datum key1);
extern HeapTuple SearchSysCache2(SysCacheIdentifier cacheId,
                                 Datum key1, Datum key2);
extern HeapTuple SearchSysCache3(SysCacheIdentifier cacheId,
                                 Datum key1, Datum key2, Datum key3);
extern HeapTuple SearchSysCache4(SysCacheIdentifier cacheId,
                                 Datum key1, Datum key2, Datum key3, Datum key4);
 
extern void ReleaseSysCache(HeapTuple tuple);
 
extern HeapTuple SearchSysCacheLocked1(SysCacheIdentifier cacheId,
                                       Datum key1);
 
/* convenience routines */
extern HeapTuple SearchSysCacheCopy(SysCacheIdentifier cacheId,
                                    Datum key1, Datum key2, Datum key3, Datum key4);
extern HeapTuple SearchSysCacheLockedCopy1(SysCacheIdentifier cacheId,
                                           Datum key1);
extern bool SearchSysCacheExists(SysCacheIdentifier cacheId,
                                 Datum key1, Datum key2, Datum key3, Datum key4);
extern Oid  GetSysCacheOid(SysCacheIdentifier cacheId, AttrNumber oidcol,
                           Datum key1, Datum key2, Datum key3, Datum key4);
 
extern HeapTuple SearchSysCacheAttName(Oid relid, const char *attname);
extern HeapTuple SearchSysCacheCopyAttName(Oid relid, const char *attname);
extern bool SearchSysCacheExistsAttName(Oid relid, const char *attname);
 
extern HeapTuple SearchSysCacheAttNum(Oid relid, int16 attnum);
extern HeapTuple SearchSysCacheCopyAttNum(Oid relid, int16 attnum);
 
extern Datum SysCacheGetAttr(SysCacheIdentifier cacheId, HeapTuple tup,
                             AttrNumber attributeNumber, bool *isNull);
 
extern Datum SysCacheGetAttrNotNull(SysCacheIdentifier cacheId, HeapTuple tup,
                                    AttrNumber attributeNumber);
 
extern uint32 GetSysCacheHashValue(SysCacheIdentifier cacheId,
                                   Datum key1, Datum key2, Datum key3, Datum key4);
 
/* list-search interface.  Users of this must import catcache.h too */
struct catclist;
extern struct catclist *SearchSysCacheList(SysCacheIdentifier cacheId, int nkeys,
                                           Datum key1, Datum key2, Datum key3);
 
extern void SysCacheInvalidate(SysCacheIdentifier cacheId, uint32 hashValue);
 
extern bool RelationInvalidatesSnapshotsOnly(Oid relid);
extern bool RelationHasSysCache(Oid relid);
extern bool RelationSupportsSysCache(Oid relid);
 
/*
 * The use of the macros below rather than direct calls to the corresponding
 * functions is encouraged, as it insulates the caller from changes in the
 * maximum number of keys.
 */
#define SearchSysCacheCopy1(cacheId, key1) \
    SearchSysCacheCopy(cacheId, key1, 0, 0, 0)
#define SearchSysCacheCopy2(cacheId, key1, key2) \
    SearchSysCacheCopy(cacheId, key1, key2, 0, 0)
#define SearchSysCacheCopy3(cacheId, key1, key2, key3) \
    SearchSysCacheCopy(cacheId, key1, key2, key3, 0)
#define SearchSysCacheCopy4(cacheId, key1, key2, key3, key4) \
    SearchSysCacheCopy(cacheId, key1, key2, key3, key4)
 
#define SearchSysCacheExists1(cacheId, key1) \
    SearchSysCacheExists(cacheId, key1, 0, 0, 0)
#define SearchSysCacheExists2(cacheId, key1, key2) \
    SearchSysCacheExists(cacheId, key1, key2, 0, 0)
#define SearchSysCacheExists3(cacheId, key1, key2, key3) \
    SearchSysCacheExists(cacheId, key1, key2, key3, 0)
#define SearchSysCacheExists4(cacheId, key1, key2, key3, key4) \
    SearchSysCacheExists(cacheId, key1, key2, key3, key4)
 
#define GetSysCacheOid1(cacheId, oidcol, key1) \
    GetSysCacheOid(cacheId, oidcol, key1, 0, 0, 0)
#define GetSysCacheOid2(cacheId, oidcol, key1, key2) \
    GetSysCacheOid(cacheId, oidcol, key1, key2, 0, 0)
#define GetSysCacheOid3(cacheId, oidcol, key1, key2, key3) \
    GetSysCacheOid(cacheId, oidcol, key1, key2, key3, 0)
#define GetSysCacheOid4(cacheId, oidcol, key1, key2, key3, key4) \
    GetSysCacheOid(cacheId, oidcol, key1, key2, key3, key4)
 
#define GetSysCacheHashValue1(cacheId, key1) \
    GetSysCacheHashValue(cacheId, key1, 0, 0, 0)
#define GetSysCacheHashValue2(cacheId, key1, key2) \
    GetSysCacheHashValue(cacheId, key1, key2, 0, 0)
#define GetSysCacheHashValue3(cacheId, key1, key2, key3) \
    GetSysCacheHashValue(cacheId, key1, key2, key3, 0)
#define GetSysCacheHashValue4(cacheId, key1, key2, key3, key4) \
    GetSysCacheHashValue(cacheId, key1, key2, key3, key4)
 
#define SearchSysCacheList1(cacheId, key1) \
    SearchSysCacheList(cacheId, 1, key1, 0, 0)
#define SearchSysCacheList2(cacheId, key1, key2) \
    SearchSysCacheList(cacheId, 2, key1, key2, 0)
#define SearchSysCacheList3(cacheId, key1, key2, key3) \
    SearchSysCacheList(cacheId, 3, key1, key2, key3)
 
#define ReleaseSysCacheList(x)  ReleaseCatCacheList(x)
 
#endif                          /* SYSCACHE_H */