/Users/deen/code/yugabyte-db/src/postgres/src/include/utils/catcache.h
Line | Count | Source |
1 | | /*------------------------------------------------------------------------- |
2 | | * |
3 | | * catcache.h |
4 | | * Low-level catalog cache definitions. |
5 | | * |
6 | | * NOTE: every catalog cache must have a corresponding unique index on |
7 | | * the system table that it caches --- ie, the index must match the keys |
8 | | * used to do lookups in this cache. All cache fetches are done with |
9 | | * indexscans (under normal conditions). The index should be unique to |
10 | | * guarantee that there can only be one matching row for a key combination. |
11 | | * |
12 | | * |
13 | | * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group |
14 | | * Portions Copyright (c) 1994, Regents of the University of California |
15 | | * |
16 | | * src/include/utils/catcache.h |
17 | | * |
18 | | *------------------------------------------------------------------------- |
19 | | */ |
20 | | #ifndef CATCACHE_H |
21 | | #define CATCACHE_H |
22 | | |
23 | | #include "access/htup.h" |
24 | | #include "access/skey.h" |
25 | | #include "lib/ilist.h" |
26 | | #include "utils/relcache.h" |
27 | | |
28 | | /* |
29 | | * struct catctup: individual tuple in the cache. |
30 | | * struct catclist: list of tuples matching a partial key. |
31 | | * struct catcache: information for managing a cache. |
32 | | * struct catcacheheader: information for managing all the caches. |
33 | | */ |
34 | | |
35 | 154M | #define CATCACHE_MAXKEYS 4 |
36 | | |
37 | | |
38 | | /* function computing a datum's hash */ |
39 | | typedef uint32 (*CCHashFN) (Datum datum); |
40 | | |
41 | | /* function computing equality of two datums */ |
42 | | typedef bool (*CCFastEqualFN) (Datum a, Datum b); |
43 | | |
44 | | typedef struct catcache |
45 | | { |
46 | | int id; /* cache identifier --- see syscache.h */ |
47 | | int cc_nbuckets; /* # of hash buckets in this cache */ |
48 | | TupleDesc cc_tupdesc; /* tuple descriptor (copied from reldesc) */ |
49 | | dlist_head *cc_bucket; /* hash buckets */ |
50 | | CCHashFN cc_hashfunc[CATCACHE_MAXKEYS]; /* hash function for each key */ |
51 | | CCFastEqualFN cc_fastequal[CATCACHE_MAXKEYS]; /* fast equal function for |
52 | | * each key */ |
53 | | int cc_keyno[CATCACHE_MAXKEYS]; /* AttrNumber of each key */ |
54 | | dlist_head cc_lists; /* list of CatCList structs */ |
55 | | int cc_ntup; /* # of tuples currently in this cache */ |
56 | | int cc_nkeys; /* # of keys (1..CATCACHE_MAXKEYS) */ |
57 | | const char *cc_relname; /* name of relation the tuples come from */ |
58 | | Oid cc_reloid; /* OID of relation the tuples come from */ |
59 | | Oid cc_indexoid; /* OID of index matching cache keys */ |
60 | | bool cc_relisshared; /* is relation shared across databases? */ |
61 | | slist_node cc_next; /* list link */ |
62 | | ScanKeyData cc_skey[CATCACHE_MAXKEYS]; /* precomputed key info for heap |
63 | | * scans */ |
64 | | |
65 | | /* |
66 | | * Keep these at the end, so that compiling catcache.c with CATCACHE_STATS |
67 | | * doesn't break ABI for other modules |
68 | | */ |
69 | | #ifdef CATCACHE_STATS |
70 | | long cc_searches; /* total # searches against this cache */ |
71 | | long cc_hits; /* # of matches against existing entry */ |
72 | | long cc_neg_hits; /* # of matches against negative entry */ |
73 | | long cc_newloads; /* # of successful loads of new entry */ |
74 | | |
75 | | /* |
76 | | * cc_searches - (cc_hits + cc_neg_hits + cc_newloads) is number of failed |
77 | | * searches, each of which will result in loading a negative entry |
78 | | */ |
79 | | long cc_invals; /* # of entries invalidated from cache */ |
80 | | long cc_lsearches; /* total # list-searches */ |
81 | | long cc_lhits; /* # of matches against existing lists */ |
82 | | #endif |
83 | | } CatCache; |
84 | | |
85 | | |
86 | | typedef struct catctup |
87 | | { |
88 | | int ct_magic; /* for identifying CatCTup entries */ |
89 | 31.9M | #define CT_MAGIC 0x57261502 |
90 | | |
91 | | uint32 hash_value; /* hash value for this tuple's keys */ |
92 | | |
93 | | /* |
94 | | * Lookup keys for the entry. By-reference datums point into the tuple for |
95 | | * positive cache entries, and are separately allocated for negative ones. |
96 | | */ |
97 | | Datum keys[CATCACHE_MAXKEYS]; |
98 | | |
99 | | /* |
100 | | * Each tuple in a cache is a member of a dlist that stores the elements |
101 | | * of its hash bucket. We keep each dlist in LRU order to speed repeated |
102 | | * lookups. |
103 | | */ |
104 | | dlist_node cache_elem; /* list member of per-bucket list */ |
105 | | |
106 | | /* |
107 | | * A tuple marked "dead" must not be returned by subsequent searches. |
108 | | * However, it won't be physically deleted from the cache until its |
109 | | * refcount goes to zero. (If it's a member of a CatCList, the list's |
110 | | * refcount must go to zero, too; also, remember to mark the list dead at |
111 | | * the same time the tuple is marked.) |
112 | | * |
113 | | * A negative cache entry is an assertion that there is no tuple matching |
114 | | * a particular key. This is just as useful as a normal entry so far as |
115 | | * avoiding catalog searches is concerned. Management of positive and |
116 | | * negative entries is identical. |
117 | | */ |
118 | | int refcount; /* number of active references */ |
119 | | bool dead; /* dead but not yet removed? */ |
120 | | bool negative; /* negative cache entry? */ |
121 | | HeapTupleData tuple; /* tuple management header */ |
122 | | |
123 | | /* |
124 | | * The tuple may also be a member of at most one CatCList. (If a single |
125 | | * catcache is list-searched with varying numbers of keys, we may have to |
126 | | * make multiple entries for the same tuple because of this restriction. |
127 | | * Currently, that's not expected to be common, so we accept the potential |
128 | | * inefficiency.) |
129 | | */ |
130 | | struct catclist *c_list; /* containing CatCList, or NULL if none */ |
131 | | |
132 | | CatCache *my_cache; /* link to owning catcache */ |
133 | | /* properly aligned tuple data follows, unless a negative entry */ |
134 | | } CatCTup; |
135 | | |
136 | | |
137 | | /* |
138 | | * A CatCList describes the result of a partial search, ie, a search using |
139 | | * only the first K key columns of an N-key cache. We store the keys used |
140 | | * into the keys attribute to represent the stored key set. The CatCList |
141 | | * object contains links to cache entries for all the table rows satisfying |
142 | | * the partial key. (Note: none of these will be negative cache entries.) |
143 | | * |
144 | | * A CatCList is only a member of a per-cache list; we do not currently |
145 | | * divide them into hash buckets. |
146 | | * |
147 | | * A list marked "dead" must not be returned by subsequent searches. |
148 | | * However, it won't be physically deleted from the cache until its |
149 | | * refcount goes to zero. (A list should be marked dead if any of its |
150 | | * member entries are dead.) |
151 | | * |
152 | | * If "ordered" is true then the member tuples appear in the order of the |
153 | | * cache's underlying index. This will be true in normal operation, but |
154 | | * might not be true during bootstrap or recovery operations. (namespace.c |
155 | | * is able to save some cycles when it is true.) |
156 | | */ |
157 | | typedef struct catclist |
158 | | { |
159 | | int cl_magic; /* for identifying CatCList entries */ |
160 | 714k | #define CL_MAGIC 0x52765103 |
161 | | |
162 | | uint32 hash_value; /* hash value for lookup keys */ |
163 | | |
164 | | dlist_node cache_elem; /* list member of per-catcache list */ |
165 | | |
166 | | /* |
167 | | * Lookup keys for the entry, with the first nkeys elements being valid. |
168 | | * All by-reference are separately allocated. |
169 | | */ |
170 | | Datum keys[CATCACHE_MAXKEYS]; |
171 | | |
172 | | int refcount; /* number of active references */ |
173 | | bool dead; /* dead but not yet removed? */ |
174 | | bool ordered; /* members listed in index order? */ |
175 | | short nkeys; /* number of lookup keys specified */ |
176 | | int n_members; /* number of member tuples */ |
177 | | CatCache *my_cache; /* link to owning catcache */ |
178 | | CatCTup *members[FLEXIBLE_ARRAY_MEMBER]; /* members */ |
179 | | } CatCList; |
180 | | |
181 | | |
182 | | typedef struct catcacheheader |
183 | | { |
184 | | slist_head ch_caches; /* head of list of CatCache structs */ |
185 | | int ch_ntup; /* # of tuples in all caches */ |
186 | | } CatCacheHeader; |
187 | | |
188 | | |
189 | | /* this extern duplicates utils/memutils.h... */ |
190 | | extern PGDLLIMPORT MemoryContext CacheMemoryContext; |
191 | | |
192 | | extern void CreateCacheMemoryContext(void); |
193 | | |
194 | | extern CatCache *InitCatCache(int id, Oid reloid, Oid indexoid, |
195 | | int nkeys, const int *key, |
196 | | int nbuckets); |
197 | | |
198 | | extern void InitCatCachePhase2(CatCache *cache, bool touch_index); |
199 | | |
200 | | extern HeapTuple SearchCatCache(CatCache *cache, |
201 | | Datum v1, Datum v2, Datum v3, Datum v4); |
202 | | extern HeapTuple SearchCatCache1(CatCache *cache, |
203 | | Datum v1); |
204 | | extern HeapTuple SearchCatCache2(CatCache *cache, |
205 | | Datum v1, Datum v2); |
206 | | extern HeapTuple SearchCatCache3(CatCache *cache, |
207 | | Datum v1, Datum v2, Datum v3); |
208 | | extern HeapTuple SearchCatCache4(CatCache *cache, |
209 | | Datum v1, Datum v2, Datum v3, Datum v4); |
210 | | extern void ReleaseCatCache(HeapTuple tuple); |
211 | | |
212 | | extern uint32 GetCatCacheHashValue(CatCache *cache, |
213 | | Datum v1, Datum v2, |
214 | | Datum v3, Datum v4); |
215 | | |
216 | | /* Used in IsYugaByteEnabled() mode only */ |
217 | | extern void SetCatCacheTuple(CatCache *cache, HeapTuple tup, TupleDesc tupdesc); |
218 | | extern void SetCatCacheList(CatCache *cache, int nkeys, List *fnlist); |
219 | | |
220 | | extern CatCList *SearchCatCacheList(CatCache *cache, int nkeys, |
221 | | Datum v1, Datum v2, |
222 | | Datum v3); |
223 | | extern void ReleaseCatCacheList(CatCList *list); |
224 | | |
225 | | extern void ResetCatalogCaches(void); |
226 | | extern void CatalogCacheFlushCatalog(Oid catId); |
227 | | extern void CatCacheInvalidate(CatCache *cache, uint32 hashValue); |
228 | | extern void PrepareToInvalidateCacheTuple(Relation relation, |
229 | | HeapTuple tuple, |
230 | | HeapTuple newtuple, |
231 | | void (*function) (int, uint32, Oid)); |
232 | | extern bool RelationHasCachedLists(Relation relation); |
233 | | |
234 | | extern void PrintCatCacheLeakWarning(HeapTuple tuple); |
235 | | extern void PrintCatCacheListLeakWarning(CatCList *list); |
236 | | |
237 | | extern long GetCatCacheMisses(); |
238 | | |
239 | | #endif /* CATCACHE_H */ |