Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * typcache.c
4 : : * POSTGRES type cache code
5 : : *
6 : : * The type cache exists to speed lookup of certain information about data
7 : : * types that is not directly available from a type's pg_type row. For
8 : : * example, we use a type's default btree opclass, or the default hash
9 : : * opclass if no btree opclass exists, to determine which operators should
10 : : * be used for grouping and sorting the type (GROUP BY, ORDER BY ASC/DESC).
11 : : *
12 : : * Several seemingly-odd choices have been made to support use of the type
13 : : * cache by generic array and record handling routines, such as array_eq(),
14 : : * record_cmp(), and hash_array(). Because those routines are used as index
15 : : * support operations, they cannot leak memory. To allow them to execute
16 : : * efficiently, all information that they would like to re-use across calls
17 : : * is kept in the type cache.
18 : : *
19 : : * Once created, a type cache entry lives as long as the backend does, so
20 : : * there is no need for a call to release a cache entry. If the type is
21 : : * dropped, the cache entry simply becomes wasted storage. This is not
22 : : * expected to happen often, and assuming that typcache entries are good
23 : : * permanently allows caching pointers to them in long-lived places.
24 : : *
25 : : * We have some provisions for updating cache entries if the stored data
26 : : * becomes obsolete. Core data extracted from the pg_type row is updated
27 : : * when we detect updates to pg_type. Information dependent on opclasses is
28 : : * cleared if we detect updates to pg_opclass. We also support clearing the
29 : : * tuple descriptor and operator/function parts of a rowtype's cache entry,
30 : : * since those may need to change as a consequence of ALTER TABLE. Domain
31 : : * constraint changes are also tracked properly.
32 : : *
33 : : *
34 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
35 : : * Portions Copyright (c) 1994, Regents of the University of California
36 : : *
37 : : * IDENTIFICATION
38 : : * src/backend/utils/cache/typcache.c
39 : : *
40 : : *-------------------------------------------------------------------------
41 : : */
42 : : #include "postgres.h"
43 : :
44 : : #include <limits.h>
45 : :
46 : : #include "access/hash.h"
47 : : #include "access/htup_details.h"
48 : : #include "access/nbtree.h"
49 : : #include "access/parallel.h"
50 : : #include "access/relation.h"
51 : : #include "access/session.h"
52 : : #include "access/table.h"
53 : : #include "catalog/pg_am.h"
54 : : #include "catalog/pg_constraint.h"
55 : : #include "catalog/pg_enum.h"
56 : : #include "catalog/pg_operator.h"
57 : : #include "catalog/pg_range.h"
58 : : #include "catalog/pg_type.h"
59 : : #include "commands/defrem.h"
60 : : #include "common/int.h"
61 : : #include "executor/executor.h"
62 : : #include "lib/dshash.h"
63 : : #include "optimizer/optimizer.h"
64 : : #include "port/pg_bitutils.h"
65 : : #include "storage/lwlock.h"
66 : : #include "utils/builtins.h"
67 : : #include "utils/catcache.h"
68 : : #include "utils/fmgroids.h"
69 : : #include "utils/injection_point.h"
70 : : #include "utils/inval.h"
71 : : #include "utils/lsyscache.h"
72 : : #include "utils/memutils.h"
73 : : #include "utils/rel.h"
74 : : #include "utils/syscache.h"
75 : : #include "utils/typcache.h"
76 : :
77 : :
78 : : /* The main type cache hashtable searched by lookup_type_cache */
79 : : static HTAB *TypeCacheHash = NULL;
80 : :
81 : : /*
82 : : * The mapping of relation's OID to the corresponding composite type OID.
83 : : * We're keeping the map entry when the corresponding typentry has something
84 : : * to clear i.e it has either TCFLAGS_HAVE_PG_TYPE_DATA, or
85 : : * TCFLAGS_OPERATOR_FLAGS, or tupdesc.
86 : : */
87 : : static HTAB *RelIdToTypeIdCacheHash = NULL;
88 : :
89 : : typedef struct RelIdToTypeIdCacheEntry
90 : : {
91 : : Oid relid; /* OID of the relation */
92 : : Oid composite_typid; /* OID of the relation's composite type */
93 : : } RelIdToTypeIdCacheEntry;
94 : :
95 : : /* List of type cache entries for domain types */
96 : : static TypeCacheEntry *firstDomainTypeEntry = NULL;
97 : :
98 : : /* Private flag bits in the TypeCacheEntry.flags field */
99 : : #define TCFLAGS_HAVE_PG_TYPE_DATA 0x000001
100 : : #define TCFLAGS_CHECKED_BTREE_OPCLASS 0x000002
101 : : #define TCFLAGS_CHECKED_HASH_OPCLASS 0x000004
102 : : #define TCFLAGS_CHECKED_EQ_OPR 0x000008
103 : : #define TCFLAGS_CHECKED_LT_OPR 0x000010
104 : : #define TCFLAGS_CHECKED_GT_OPR 0x000020
105 : : #define TCFLAGS_CHECKED_CMP_PROC 0x000040
106 : : #define TCFLAGS_CHECKED_HASH_PROC 0x000080
107 : : #define TCFLAGS_CHECKED_HASH_EXTENDED_PROC 0x000100
108 : : #define TCFLAGS_CHECKED_ELEM_PROPERTIES 0x000200
109 : : #define TCFLAGS_HAVE_ELEM_EQUALITY 0x000400
110 : : #define TCFLAGS_HAVE_ELEM_COMPARE 0x000800
111 : : #define TCFLAGS_HAVE_ELEM_HASHING 0x001000
112 : : #define TCFLAGS_HAVE_ELEM_EXTENDED_HASHING 0x002000
113 : : #define TCFLAGS_CHECKED_FIELD_PROPERTIES 0x004000
114 : : #define TCFLAGS_HAVE_FIELD_EQUALITY 0x008000
115 : : #define TCFLAGS_HAVE_FIELD_COMPARE 0x010000
116 : : #define TCFLAGS_HAVE_FIELD_HASHING 0x020000
117 : : #define TCFLAGS_HAVE_FIELD_EXTENDED_HASHING 0x040000
118 : : #define TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS 0x080000
119 : : #define TCFLAGS_DOMAIN_BASE_IS_COMPOSITE 0x100000
120 : :
121 : : /* The flags associated with equality/comparison/hashing are all but these: */
122 : : #define TCFLAGS_OPERATOR_FLAGS \
123 : : (~(TCFLAGS_HAVE_PG_TYPE_DATA | \
124 : : TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS | \
125 : : TCFLAGS_DOMAIN_BASE_IS_COMPOSITE))
126 : :
127 : : /*
128 : : * Data stored about a domain type's constraints. Note that we do not create
129 : : * this struct for the common case of a constraint-less domain; we just set
130 : : * domainData to NULL to indicate that.
131 : : *
132 : : * Within a DomainConstraintCache, we store expression plan trees, but the
133 : : * check_exprstate fields of the DomainConstraintState nodes are just NULL.
134 : : * When needed, expression evaluation nodes are built by flat-copying the
135 : : * DomainConstraintState nodes and applying ExecInitExpr to check_expr.
136 : : * Such a node tree is not part of the DomainConstraintCache, but is
137 : : * considered to belong to a DomainConstraintRef.
138 : : */
139 : : struct DomainConstraintCache
140 : : {
141 : : List *constraints; /* list of DomainConstraintState nodes */
142 : : MemoryContext dccContext; /* memory context holding all associated data */
143 : : long dccRefCount; /* number of references to this struct */
144 : : };
145 : :
146 : : /* Private information to support comparisons of enum values */
147 : : typedef struct
148 : : {
149 : : Oid enum_oid; /* OID of one enum value */
150 : : float4 sort_order; /* its sort position */
151 : : } EnumItem;
152 : :
153 : : typedef struct TypeCacheEnumData
154 : : {
155 : : Oid bitmap_base; /* OID corresponding to bit 0 of bitmapset */
156 : : Bitmapset *sorted_values; /* Set of OIDs known to be in order */
157 : : int num_values; /* total number of values in enum */
158 : : EnumItem enum_values[FLEXIBLE_ARRAY_MEMBER];
159 : : } TypeCacheEnumData;
160 : :
161 : : /*
162 : : * We use a separate table for storing the definitions of non-anonymous
163 : : * record types. Once defined, a record type will be remembered for the
164 : : * life of the backend. Subsequent uses of the "same" record type (where
165 : : * sameness means equalRowTypes) will refer to the existing table entry.
166 : : *
167 : : * Stored record types are remembered in a linear array of TupleDescs,
168 : : * which can be indexed quickly with the assigned typmod. There is also
169 : : * a hash table to speed searches for matching TupleDescs.
170 : : */
171 : :
172 : : typedef struct RecordCacheEntry
173 : : {
174 : : TupleDesc tupdesc;
175 : : } RecordCacheEntry;
176 : :
177 : : /*
178 : : * To deal with non-anonymous record types that are exchanged by backends
179 : : * involved in a parallel query, we also need a shared version of the above.
180 : : */
181 : : struct SharedRecordTypmodRegistry
182 : : {
183 : : /* A hash table for finding a matching TupleDesc. */
184 : : dshash_table_handle record_table_handle;
185 : : /* A hash table for finding a TupleDesc by typmod. */
186 : : dshash_table_handle typmod_table_handle;
187 : : /* A source of new record typmod numbers. */
188 : : pg_atomic_uint32 next_typmod;
189 : : };
190 : :
191 : : /*
192 : : * When using shared tuple descriptors as hash table keys we need a way to be
193 : : * able to search for an equal shared TupleDesc using a backend-local
194 : : * TupleDesc. So we use this type which can hold either, and hash and compare
195 : : * functions that know how to handle both.
196 : : */
197 : : typedef struct SharedRecordTableKey
198 : : {
199 : : union
200 : : {
201 : : TupleDesc local_tupdesc;
202 : : dsa_pointer shared_tupdesc;
203 : : } u;
204 : : bool shared;
205 : : } SharedRecordTableKey;
206 : :
207 : : /*
208 : : * The shared version of RecordCacheEntry. This lets us look up a typmod
209 : : * using a TupleDesc which may be in local or shared memory.
210 : : */
211 : : typedef struct SharedRecordTableEntry
212 : : {
213 : : SharedRecordTableKey key;
214 : : } SharedRecordTableEntry;
215 : :
216 : : /*
217 : : * An entry in SharedRecordTypmodRegistry's typmod table. This lets us look
218 : : * up a TupleDesc in shared memory using a typmod.
219 : : */
220 : : typedef struct SharedTypmodTableEntry
221 : : {
222 : : uint32 typmod;
223 : : dsa_pointer shared_tupdesc;
224 : : } SharedTypmodTableEntry;
225 : :
226 : : static Oid *in_progress_list;
227 : : static int in_progress_list_len;
228 : : static int in_progress_list_maxlen;
229 : :
230 : : /*
231 : : * A comparator function for SharedRecordTableKey.
232 : : */
233 : : static int
234 : 21 : shared_record_table_compare(const void *a, const void *b, size_t size,
235 : : void *arg)
236 : : {
237 : 21 : dsa_area *area = (dsa_area *) arg;
238 : 21 : const SharedRecordTableKey *k1 = a;
239 : 21 : const SharedRecordTableKey *k2 = b;
240 : 21 : TupleDesc t1;
241 : 21 : TupleDesc t2;
242 : :
243 [ - + ]: 21 : if (k1->shared)
244 : 0 : t1 = (TupleDesc) dsa_get_address(area, k1->u.shared_tupdesc);
245 : : else
246 : 21 : t1 = k1->u.local_tupdesc;
247 : :
248 [ + - ]: 21 : if (k2->shared)
249 : 21 : t2 = (TupleDesc) dsa_get_address(area, k2->u.shared_tupdesc);
250 : : else
251 : 0 : t2 = k2->u.local_tupdesc;
252 : :
253 : 42 : return equalRowTypes(t1, t2) ? 0 : 1;
254 : 21 : }
255 : :
256 : : /*
257 : : * A hash function for SharedRecordTableKey.
258 : : */
259 : : static uint32
260 : 41 : shared_record_table_hash(const void *a, size_t size, void *arg)
261 : : {
262 : 41 : dsa_area *area = arg;
263 : 41 : const SharedRecordTableKey *k = a;
264 : 41 : TupleDesc t;
265 : :
266 [ - + ]: 41 : if (k->shared)
267 : 0 : t = (TupleDesc) dsa_get_address(area, k->u.shared_tupdesc);
268 : : else
269 : 41 : t = k->u.local_tupdesc;
270 : :
271 : 82 : return hashRowType(t);
272 : 41 : }
273 : :
274 : : /* Parameters for SharedRecordTypmodRegistry's TupleDesc table. */
275 : : static const dshash_parameters srtr_record_table_params = {
276 : : sizeof(SharedRecordTableKey), /* unused */
277 : : sizeof(SharedRecordTableEntry),
278 : : shared_record_table_compare,
279 : : shared_record_table_hash,
280 : : dshash_memcpy,
281 : : LWTRANCHE_PER_SESSION_RECORD_TYPE
282 : : };
283 : :
284 : : /* Parameters for SharedRecordTypmodRegistry's typmod hash table. */
285 : : static const dshash_parameters srtr_typmod_table_params = {
286 : : sizeof(uint32),
287 : : sizeof(SharedTypmodTableEntry),
288 : : dshash_memcmp,
289 : : dshash_memhash,
290 : : dshash_memcpy,
291 : : LWTRANCHE_PER_SESSION_RECORD_TYPMOD
292 : : };
293 : :
294 : : /* hashtable for recognizing registered record types */
295 : : static HTAB *RecordCacheHash = NULL;
296 : :
297 : : typedef struct RecordCacheArrayEntry
298 : : {
299 : : uint64 id;
300 : : TupleDesc tupdesc;
301 : : } RecordCacheArrayEntry;
302 : :
303 : : /* array of info about registered record types, indexed by assigned typmod */
304 : : static RecordCacheArrayEntry *RecordCacheArray = NULL;
305 : : static int32 RecordCacheArrayLen = 0; /* allocated length of above array */
306 : : static int32 NextRecordTypmod = 0; /* number of entries used */
307 : :
308 : : /*
309 : : * Process-wide counter for generating unique tupledesc identifiers.
310 : : * Zero and one (INVALID_TUPLEDESC_IDENTIFIER) aren't allowed to be chosen
311 : : * as identifiers, so we start the counter at INVALID_TUPLEDESC_IDENTIFIER.
312 : : */
313 : : static uint64 tupledesc_id_counter = INVALID_TUPLEDESC_IDENTIFIER;
314 : :
315 : : static void load_typcache_tupdesc(TypeCacheEntry *typentry);
316 : : static void load_rangetype_info(TypeCacheEntry *typentry);
317 : : static void load_multirangetype_info(TypeCacheEntry *typentry);
318 : : static void load_domaintype_info(TypeCacheEntry *typentry);
319 : : static int dcs_cmp(const void *a, const void *b);
320 : : static void decr_dcc_refcount(DomainConstraintCache *dcc);
321 : : static void dccref_deletion_callback(void *arg);
322 : : static List *prep_domain_constraints(List *constraints, MemoryContext execctx);
323 : : static bool array_element_has_equality(TypeCacheEntry *typentry);
324 : : static bool array_element_has_compare(TypeCacheEntry *typentry);
325 : : static bool array_element_has_hashing(TypeCacheEntry *typentry);
326 : : static bool array_element_has_extended_hashing(TypeCacheEntry *typentry);
327 : : static void cache_array_element_properties(TypeCacheEntry *typentry);
328 : : static bool record_fields_have_equality(TypeCacheEntry *typentry);
329 : : static bool record_fields_have_compare(TypeCacheEntry *typentry);
330 : : static bool record_fields_have_hashing(TypeCacheEntry *typentry);
331 : : static bool record_fields_have_extended_hashing(TypeCacheEntry *typentry);
332 : : static void cache_record_field_properties(TypeCacheEntry *typentry);
333 : : static bool range_element_has_hashing(TypeCacheEntry *typentry);
334 : : static bool range_element_has_extended_hashing(TypeCacheEntry *typentry);
335 : : static void cache_range_element_properties(TypeCacheEntry *typentry);
336 : : static bool multirange_element_has_hashing(TypeCacheEntry *typentry);
337 : : static bool multirange_element_has_extended_hashing(TypeCacheEntry *typentry);
338 : : static void cache_multirange_element_properties(TypeCacheEntry *typentry);
339 : : static void TypeCacheRelCallback(Datum arg, Oid relid);
340 : : static void TypeCacheTypCallback(Datum arg, int cacheid, uint32 hashvalue);
341 : : static void TypeCacheOpcCallback(Datum arg, int cacheid, uint32 hashvalue);
342 : : static void TypeCacheConstrCallback(Datum arg, int cacheid, uint32 hashvalue);
343 : : static void load_enum_cache_data(TypeCacheEntry *tcache);
344 : : static EnumItem *find_enumitem(TypeCacheEnumData *enumdata, Oid arg);
345 : : static int enum_oid_cmp(const void *left, const void *right);
346 : : static void shared_record_typmod_registry_detach(dsm_segment *segment,
347 : : Datum datum);
348 : : static TupleDesc find_or_make_matching_shared_tupledesc(TupleDesc tupdesc);
349 : : static dsa_pointer share_tupledesc(dsa_area *area, TupleDesc tupdesc,
350 : : uint32 typmod);
351 : : static void insert_rel_type_cache_if_needed(TypeCacheEntry *typentry);
352 : : static void delete_rel_type_cache_if_needed(TypeCacheEntry *typentry);
353 : :
354 : :
355 : : /*
356 : : * Hash function compatible with one-arg system cache hash function.
357 : : */
358 : : static uint32
359 : 77456 : type_cache_syshash(const void *key, Size keysize)
360 : : {
361 [ + - ]: 77456 : Assert(keysize == sizeof(Oid));
362 : 77456 : return GetSysCacheHashValue1(TYPEOID, ObjectIdGetDatum(*(const Oid *) key));
363 : : }
364 : :
365 : : /*
366 : : * lookup_type_cache
367 : : *
368 : : * Fetch the type cache entry for the specified datatype, and make sure that
369 : : * all the fields requested by bits in 'flags' are valid.
370 : : *
371 : : * The result is never NULL --- we will ereport() if the passed type OID is
372 : : * invalid. Note however that we may fail to find one or more of the
373 : : * values requested by 'flags'; the caller needs to check whether the fields
374 : : * are InvalidOid or not.
375 : : *
376 : : * Note that while filling TypeCacheEntry we might process concurrent
377 : : * invalidation messages, causing our not-yet-filled TypeCacheEntry to be
378 : : * invalidated. In this case, we typically only clear flags while values are
379 : : * still available for the caller. It's expected that the caller holds
380 : : * enough locks on type-depending objects that the values are still relevant.
381 : : * It's also important that the tupdesc is filled after all other
382 : : * TypeCacheEntry items for TYPTYPE_COMPOSITE. So, tupdesc can't get
383 : : * invalidated during the lookup_type_cache() call.
384 : : */
385 : : TypeCacheEntry *
386 : 72684 : lookup_type_cache(Oid type_id, int flags)
387 : : {
388 : 72684 : TypeCacheEntry *typentry;
389 : 72684 : bool found;
390 : 72684 : int in_progress_offset;
391 : :
392 [ + + ]: 72684 : if (TypeCacheHash == NULL)
393 : : {
394 : : /* First time through: initialize the hash table */
395 : 214 : HASHCTL ctl;
396 : 214 : int allocsize;
397 : :
398 : 214 : ctl.keysize = sizeof(Oid);
399 : 214 : ctl.entrysize = sizeof(TypeCacheEntry);
400 : :
401 : : /*
402 : : * TypeCacheEntry takes hash value from the system cache. For
403 : : * TypeCacheHash we use the same hash in order to speedup search by
404 : : * hash value. This is used by hash_seq_init_with_hash_value().
405 : : */
406 : 214 : ctl.hash = type_cache_syshash;
407 : :
408 : 214 : TypeCacheHash = hash_create("Type information cache", 64,
409 : : &ctl, HASH_ELEM | HASH_FUNCTION);
410 : :
411 [ + - ]: 214 : Assert(RelIdToTypeIdCacheHash == NULL);
412 : :
413 : 214 : ctl.keysize = sizeof(Oid);
414 : 214 : ctl.entrysize = sizeof(RelIdToTypeIdCacheEntry);
415 : 214 : RelIdToTypeIdCacheHash = hash_create("Map from relid to OID of cached composite type", 64,
416 : : &ctl, HASH_ELEM | HASH_BLOBS);
417 : :
418 : : /* Also set up callbacks for SI invalidations */
419 : 214 : CacheRegisterRelcacheCallback(TypeCacheRelCallback, (Datum) 0);
420 : 214 : CacheRegisterSyscacheCallback(TYPEOID, TypeCacheTypCallback, (Datum) 0);
421 : 214 : CacheRegisterSyscacheCallback(CLAOID, TypeCacheOpcCallback, (Datum) 0);
422 : 214 : CacheRegisterSyscacheCallback(CONSTROID, TypeCacheConstrCallback, (Datum) 0);
423 : :
424 : : /* Also make sure CacheMemoryContext exists */
425 [ + - ]: 214 : if (!CacheMemoryContext)
426 : 0 : CreateCacheMemoryContext();
427 : :
428 : : /*
429 : : * reserve enough in_progress_list slots for many cases
430 : : */
431 : 214 : allocsize = 4;
432 : 214 : in_progress_list =
433 : 428 : MemoryContextAlloc(CacheMemoryContext,
434 : 214 : allocsize * sizeof(*in_progress_list));
435 : 214 : in_progress_list_maxlen = allocsize;
436 : 214 : }
437 : :
438 [ + - ]: 72684 : Assert(TypeCacheHash != NULL && RelIdToTypeIdCacheHash != NULL);
439 : :
440 : : /* Register to catch invalidation messages */
441 [ + - ]: 72684 : if (in_progress_list_len >= in_progress_list_maxlen)
442 : : {
443 : 0 : int allocsize;
444 : :
445 : 0 : allocsize = in_progress_list_maxlen * 2;
446 : 0 : in_progress_list = repalloc(in_progress_list,
447 : 0 : allocsize * sizeof(*in_progress_list));
448 : 0 : in_progress_list_maxlen = allocsize;
449 : 0 : }
450 : 72684 : in_progress_offset = in_progress_list_len++;
451 : 72684 : in_progress_list[in_progress_offset] = type_id;
452 : :
453 : : /* Try to look up an existing entry */
454 : 72684 : typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
455 : : &type_id,
456 : : HASH_FIND, NULL);
457 [ + + ]: 72684 : if (typentry == NULL)
458 : : {
459 : : /*
460 : : * If we didn't find one, we want to make one. But first look up the
461 : : * pg_type row, just to make sure we don't make a cache entry for an
462 : : * invalid type OID. If the type OID is not valid, present a
463 : : * user-facing error, since some code paths such as domain_in() allow
464 : : * this function to be reached with a user-supplied OID.
465 : : */
466 : 1663 : HeapTuple tp;
467 : 1663 : Form_pg_type typtup;
468 : :
469 : 1663 : tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
470 [ + - ]: 1663 : if (!HeapTupleIsValid(tp))
471 [ # # # # ]: 0 : ereport(ERROR,
472 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
473 : : errmsg("type with OID %u does not exist", type_id)));
474 : 1663 : typtup = (Form_pg_type) GETSTRUCT(tp);
475 [ + - ]: 1663 : if (!typtup->typisdefined)
476 [ # # # # ]: 0 : ereport(ERROR,
477 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
478 : : errmsg("type \"%s\" is only a shell",
479 : : NameStr(typtup->typname))));
480 : :
481 : : /* Now make the typcache entry */
482 : 1663 : typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
483 : : &type_id,
484 : : HASH_ENTER, &found);
485 [ + - ]: 1663 : Assert(!found); /* it wasn't there a moment ago */
486 : :
487 [ + - + - : 104769 : MemSet(typentry, 0, sizeof(TypeCacheEntry));
+ - - + +
+ ]
488 : :
489 : : /* These fields can never change, by definition */
490 : 1663 : typentry->type_id = type_id;
491 : 1663 : typentry->type_id_hash = get_hash_value(TypeCacheHash, &type_id);
492 : :
493 : : /* Keep this part in sync with the code below */
494 : 1663 : typentry->typlen = typtup->typlen;
495 : 1663 : typentry->typbyval = typtup->typbyval;
496 : 1663 : typentry->typalign = typtup->typalign;
497 : 1663 : typentry->typstorage = typtup->typstorage;
498 : 1663 : typentry->typtype = typtup->typtype;
499 : 1663 : typentry->typrelid = typtup->typrelid;
500 : 1663 : typentry->typsubscript = typtup->typsubscript;
501 : 1663 : typentry->typelem = typtup->typelem;
502 : 1663 : typentry->typarray = typtup->typarray;
503 : 1663 : typentry->typcollation = typtup->typcollation;
504 : 1663 : typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
505 : :
506 : : /* If it's a domain, immediately thread it into the domain cache list */
507 [ + + ]: 1663 : if (typentry->typtype == TYPTYPE_DOMAIN)
508 : : {
509 : 155 : typentry->nextDomain = firstDomainTypeEntry;
510 : 155 : firstDomainTypeEntry = typentry;
511 : 155 : }
512 : :
513 : 1663 : ReleaseSysCache(tp);
514 : 1663 : }
515 [ + + ]: 71021 : else if (!(typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
516 : : {
517 : : /*
518 : : * We have an entry, but its pg_type row got changed, so reload the
519 : : * data obtained directly from pg_type.
520 : : */
521 : 117 : HeapTuple tp;
522 : 117 : Form_pg_type typtup;
523 : :
524 : 117 : tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
525 [ + - ]: 117 : if (!HeapTupleIsValid(tp))
526 [ # # # # ]: 0 : ereport(ERROR,
527 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
528 : : errmsg("type with OID %u does not exist", type_id)));
529 : 117 : typtup = (Form_pg_type) GETSTRUCT(tp);
530 [ + - ]: 117 : if (!typtup->typisdefined)
531 [ # # # # ]: 0 : ereport(ERROR,
532 : : (errcode(ERRCODE_UNDEFINED_OBJECT),
533 : : errmsg("type \"%s\" is only a shell",
534 : : NameStr(typtup->typname))));
535 : :
536 : : /*
537 : : * Keep this part in sync with the code above. Many of these fields
538 : : * shouldn't ever change, particularly typtype, but copy 'em anyway.
539 : : */
540 : 117 : typentry->typlen = typtup->typlen;
541 : 117 : typentry->typbyval = typtup->typbyval;
542 : 117 : typentry->typalign = typtup->typalign;
543 : 117 : typentry->typstorage = typtup->typstorage;
544 : 117 : typentry->typtype = typtup->typtype;
545 : 117 : typentry->typrelid = typtup->typrelid;
546 : 117 : typentry->typsubscript = typtup->typsubscript;
547 : 117 : typentry->typelem = typtup->typelem;
548 : 117 : typentry->typarray = typtup->typarray;
549 : 117 : typentry->typcollation = typtup->typcollation;
550 : 117 : typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
551 : :
552 : 117 : ReleaseSysCache(tp);
553 : 117 : }
554 : :
555 : : /*
556 : : * Look up opclasses if we haven't already and any dependent info is
557 : : * requested.
558 : : */
559 : 72684 : if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_LT_OPR | TYPECACHE_GT_OPR |
560 : : TYPECACHE_CMP_PROC |
561 : : TYPECACHE_EQ_OPR_FINFO | TYPECACHE_CMP_PROC_FINFO |
562 [ + + + + ]: 72684 : TYPECACHE_BTREE_OPFAMILY)) &&
563 : 40960 : !(typentry->flags & TCFLAGS_CHECKED_BTREE_OPCLASS))
564 : : {
565 : 1238 : Oid opclass;
566 : :
567 : 1238 : opclass = GetDefaultOpClass(type_id, BTREE_AM_OID);
568 [ + + ]: 1238 : if (OidIsValid(opclass))
569 : : {
570 : 1204 : typentry->btree_opf = get_opclass_family(opclass);
571 : 1204 : typentry->btree_opintype = get_opclass_input_type(opclass);
572 : 1204 : }
573 : : else
574 : : {
575 : 34 : typentry->btree_opf = typentry->btree_opintype = InvalidOid;
576 : : }
577 : :
578 : : /*
579 : : * Reset information derived from btree opclass. Note in particular
580 : : * that we'll redetermine the eq_opr even if we previously found one;
581 : : * this matters in case a btree opclass has been added to a type that
582 : : * previously had only a hash opclass.
583 : : */
584 : 1238 : typentry->flags &= ~(TCFLAGS_CHECKED_EQ_OPR |
585 : : TCFLAGS_CHECKED_LT_OPR |
586 : : TCFLAGS_CHECKED_GT_OPR |
587 : : TCFLAGS_CHECKED_CMP_PROC);
588 : 1238 : typentry->flags |= TCFLAGS_CHECKED_BTREE_OPCLASS;
589 : 1238 : }
590 : :
591 : : /*
592 : : * If we need to look up equality operator, and there's no btree opclass,
593 : : * force lookup of hash opclass.
594 : : */
595 [ + + ]: 72684 : if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
596 [ + + + + ]: 37811 : !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR) &&
597 : 1208 : typentry->btree_opf == InvalidOid)
598 : 32 : flags |= TYPECACHE_HASH_OPFAMILY;
599 : :
600 : 72684 : if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO |
601 : : TYPECACHE_HASH_EXTENDED_PROC |
602 : : TYPECACHE_HASH_EXTENDED_PROC_FINFO |
603 [ + + + + ]: 72684 : TYPECACHE_HASH_OPFAMILY)) &&
604 : 32612 : !(typentry->flags & TCFLAGS_CHECKED_HASH_OPCLASS))
605 : : {
606 : 1058 : Oid opclass;
607 : :
608 : 1058 : opclass = GetDefaultOpClass(type_id, HASH_AM_OID);
609 [ + + ]: 1058 : if (OidIsValid(opclass))
610 : : {
611 : 1023 : typentry->hash_opf = get_opclass_family(opclass);
612 : 1023 : typentry->hash_opintype = get_opclass_input_type(opclass);
613 : 1023 : }
614 : : else
615 : : {
616 : 35 : typentry->hash_opf = typentry->hash_opintype = InvalidOid;
617 : : }
618 : :
619 : : /*
620 : : * Reset information derived from hash opclass. We do *not* reset the
621 : : * eq_opr; if we already found one from the btree opclass, that
622 : : * decision is still good.
623 : : */
624 : 1058 : typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
625 : : TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
626 : 1058 : typentry->flags |= TCFLAGS_CHECKED_HASH_OPCLASS;
627 : 1058 : }
628 : :
629 : : /*
630 : : * Look for requested operators and functions, if we haven't already.
631 : : */
632 [ + + + + ]: 72684 : if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
633 : 37811 : !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR))
634 : : {
635 : 1208 : Oid eq_opr = InvalidOid;
636 : :
637 [ + + ]: 1208 : if (typentry->btree_opf != InvalidOid)
638 : 2352 : eq_opr = get_opfamily_member(typentry->btree_opf,
639 : 1176 : typentry->btree_opintype,
640 : 1176 : typentry->btree_opintype,
641 : : BTEqualStrategyNumber);
642 [ + + + + ]: 1208 : if (eq_opr == InvalidOid &&
643 : 32 : typentry->hash_opf != InvalidOid)
644 : 12 : eq_opr = get_opfamily_member(typentry->hash_opf,
645 : 6 : typentry->hash_opintype,
646 : 6 : typentry->hash_opintype,
647 : : HTEqualStrategyNumber);
648 : :
649 : : /*
650 : : * If the proposed equality operator is array_eq or record_eq, check
651 : : * to see if the element type or column types support equality. If
652 : : * not, array_eq or record_eq would fail at runtime, so we don't want
653 : : * to report that the type has equality. (We can omit similar
654 : : * checking for ranges and multiranges because ranges can't be created
655 : : * in the first place unless their subtypes support equality.)
656 : : */
657 [ + + + + ]: 1208 : if (eq_opr == ARRAY_EQ_OP &&
658 : 36 : !array_element_has_equality(typentry))
659 : 4 : eq_opr = InvalidOid;
660 [ + + + + ]: 1204 : else if (eq_opr == RECORD_EQ_OP &&
661 : 33 : !record_fields_have_equality(typentry))
662 : 5 : eq_opr = InvalidOid;
663 : :
664 : : /* Force update of eq_opr_finfo only if we're changing state */
665 [ + + ]: 1208 : if (typentry->eq_opr != eq_opr)
666 : 972 : typentry->eq_opr_finfo.fn_oid = InvalidOid;
667 : :
668 : 1208 : typentry->eq_opr = eq_opr;
669 : :
670 : : /*
671 : : * Reset info about hash functions whenever we pick up new info about
672 : : * equality operator. This is so we can ensure that the hash
673 : : * functions match the operator.
674 : : */
675 : 1208 : typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
676 : : TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
677 : 1208 : typentry->flags |= TCFLAGS_CHECKED_EQ_OPR;
678 : 1208 : }
679 [ + + + + ]: 72684 : if ((flags & TYPECACHE_LT_OPR) &&
680 : 23198 : !(typentry->flags & TCFLAGS_CHECKED_LT_OPR))
681 : : {
682 : 915 : Oid lt_opr = InvalidOid;
683 : :
684 [ + + ]: 915 : if (typentry->btree_opf != InvalidOid)
685 : 1796 : lt_opr = get_opfamily_member(typentry->btree_opf,
686 : 898 : typentry->btree_opintype,
687 : 898 : typentry->btree_opintype,
688 : : BTLessStrategyNumber);
689 : :
690 : : /*
691 : : * As above, make sure array_cmp or record_cmp will succeed; but again
692 : : * we need no special check for ranges or multiranges.
693 : : */
694 [ + + + + ]: 915 : if (lt_opr == ARRAY_LT_OP &&
695 : 26 : !array_element_has_compare(typentry))
696 : 3 : lt_opr = InvalidOid;
697 [ + + + + ]: 912 : else if (lt_opr == RECORD_LT_OP &&
698 : 14 : !record_fields_have_compare(typentry))
699 : 2 : lt_opr = InvalidOid;
700 : :
701 : 915 : typentry->lt_opr = lt_opr;
702 : 915 : typentry->flags |= TCFLAGS_CHECKED_LT_OPR;
703 : 915 : }
704 [ + + + + ]: 72684 : if ((flags & TYPECACHE_GT_OPR) &&
705 : 22134 : !(typentry->flags & TCFLAGS_CHECKED_GT_OPR))
706 : : {
707 : 910 : Oid gt_opr = InvalidOid;
708 : :
709 [ + + ]: 910 : if (typentry->btree_opf != InvalidOid)
710 : 1788 : gt_opr = get_opfamily_member(typentry->btree_opf,
711 : 894 : typentry->btree_opintype,
712 : 894 : typentry->btree_opintype,
713 : : BTGreaterStrategyNumber);
714 : :
715 : : /*
716 : : * As above, make sure array_cmp or record_cmp will succeed; but again
717 : : * we need no special check for ranges or multiranges.
718 : : */
719 [ + + + + ]: 910 : if (gt_opr == ARRAY_GT_OP &&
720 : 26 : !array_element_has_compare(typentry))
721 : 3 : gt_opr = InvalidOid;
722 [ + + + + ]: 907 : else if (gt_opr == RECORD_GT_OP &&
723 : 14 : !record_fields_have_compare(typentry))
724 : 2 : gt_opr = InvalidOid;
725 : :
726 : 910 : typentry->gt_opr = gt_opr;
727 : 910 : typentry->flags |= TCFLAGS_CHECKED_GT_OPR;
728 : 910 : }
729 [ + + + + ]: 72684 : if ((flags & (TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO)) &&
730 : 922 : !(typentry->flags & TCFLAGS_CHECKED_CMP_PROC))
731 : : {
732 : 120 : Oid cmp_proc = InvalidOid;
733 : :
734 [ + + ]: 120 : if (typentry->btree_opf != InvalidOid)
735 : 232 : cmp_proc = get_opfamily_proc(typentry->btree_opf,
736 : 116 : typentry->btree_opintype,
737 : 116 : typentry->btree_opintype,
738 : : BTORDER_PROC);
739 : :
740 : : /*
741 : : * As above, make sure array_cmp or record_cmp will succeed; but again
742 : : * we need no special check for ranges or multiranges.
743 : : */
744 [ + + + + ]: 120 : if (cmp_proc == F_BTARRAYCMP &&
745 : 13 : !array_element_has_compare(typentry))
746 : 2 : cmp_proc = InvalidOid;
747 [ + + + + ]: 118 : else if (cmp_proc == F_BTRECORDCMP &&
748 : 12 : !record_fields_have_compare(typentry))
749 : 2 : cmp_proc = InvalidOid;
750 : :
751 : : /* Force update of cmp_proc_finfo only if we're changing state */
752 [ + + ]: 120 : if (typentry->cmp_proc != cmp_proc)
753 : 104 : typentry->cmp_proc_finfo.fn_oid = InvalidOid;
754 : :
755 : 120 : typentry->cmp_proc = cmp_proc;
756 : 120 : typentry->flags |= TCFLAGS_CHECKED_CMP_PROC;
757 : 120 : }
758 [ + + + + ]: 72684 : if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO)) &&
759 : 32581 : !(typentry->flags & TCFLAGS_CHECKED_HASH_PROC))
760 : : {
761 : 1052 : Oid hash_proc = InvalidOid;
762 : :
763 : : /*
764 : : * We insist that the eq_opr, if one has been determined, match the
765 : : * hash opclass; else report there is no hash function.
766 : : */
767 [ + + + - ]: 2058 : if (typentry->hash_opf != InvalidOid &&
768 [ + + ]: 1025 : (!OidIsValid(typentry->eq_opr) ||
769 : 2012 : typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
770 : 1006 : typentry->hash_opintype,
771 : 1006 : typentry->hash_opintype,
772 : : HTEqualStrategyNumber)))
773 : 2050 : hash_proc = get_opfamily_proc(typentry->hash_opf,
774 : 1025 : typentry->hash_opintype,
775 : 1025 : typentry->hash_opintype,
776 : : HASHSTANDARD_PROC);
777 : :
778 : : /*
779 : : * As above, make sure hash_array, hash_record, or hash_range will
780 : : * succeed.
781 : : */
782 [ + + + + ]: 1052 : if (hash_proc == F_HASH_ARRAY &&
783 : 20 : !array_element_has_hashing(typentry))
784 : 5 : hash_proc = InvalidOid;
785 [ + + + + ]: 1047 : else if (hash_proc == F_HASH_RECORD &&
786 : 31 : !record_fields_have_hashing(typentry))
787 : 11 : hash_proc = InvalidOid;
788 [ + + + + ]: 1036 : else if (hash_proc == F_HASH_RANGE &&
789 : 5 : !range_element_has_hashing(typentry))
790 : 1 : hash_proc = InvalidOid;
791 : :
792 : : /*
793 : : * Likewise for hash_multirange.
794 : : */
795 [ + + + + ]: 1052 : if (hash_proc == F_HASH_MULTIRANGE &&
796 : 3 : !multirange_element_has_hashing(typentry))
797 : 1 : hash_proc = InvalidOid;
798 : :
799 : : /* Force update of hash_proc_finfo only if we're changing state */
800 [ + + ]: 1052 : if (typentry->hash_proc != hash_proc)
801 : 830 : typentry->hash_proc_finfo.fn_oid = InvalidOid;
802 : :
803 : 1052 : typentry->hash_proc = hash_proc;
804 : 1052 : typentry->flags |= TCFLAGS_CHECKED_HASH_PROC;
805 : 1052 : }
806 : 72684 : if ((flags & (TYPECACHE_HASH_EXTENDED_PROC |
807 [ + + + + ]: 72684 : TYPECACHE_HASH_EXTENDED_PROC_FINFO)) &&
808 : 182 : !(typentry->flags & TCFLAGS_CHECKED_HASH_EXTENDED_PROC))
809 : : {
810 : 78 : Oid hash_extended_proc = InvalidOid;
811 : :
812 : : /*
813 : : * We insist that the eq_opr, if one has been determined, match the
814 : : * hash opclass; else report there is no hash function.
815 : : */
816 [ + + + - ]: 138 : if (typentry->hash_opf != InvalidOid &&
817 [ + + ]: 71 : (!OidIsValid(typentry->eq_opr) ||
818 : 120 : typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
819 : 60 : typentry->hash_opintype,
820 : 60 : typentry->hash_opintype,
821 : : HTEqualStrategyNumber)))
822 : 142 : hash_extended_proc = get_opfamily_proc(typentry->hash_opf,
823 : 71 : typentry->hash_opintype,
824 : 71 : typentry->hash_opintype,
825 : : HASHEXTENDED_PROC);
826 : :
827 : : /*
828 : : * As above, make sure hash_array_extended, hash_record_extended, or
829 : : * hash_range_extended will succeed.
830 : : */
831 [ + + + + ]: 78 : if (hash_extended_proc == F_HASH_ARRAY_EXTENDED &&
832 : 4 : !array_element_has_extended_hashing(typentry))
833 : 2 : hash_extended_proc = InvalidOid;
834 [ + + - + ]: 76 : else if (hash_extended_proc == F_HASH_RECORD_EXTENDED &&
835 : 3 : !record_fields_have_extended_hashing(typentry))
836 : 3 : hash_extended_proc = InvalidOid;
837 [ - + # # ]: 73 : else if (hash_extended_proc == F_HASH_RANGE_EXTENDED &&
838 : 0 : !range_element_has_extended_hashing(typentry))
839 : 0 : hash_extended_proc = InvalidOid;
840 : :
841 : : /*
842 : : * Likewise for hash_multirange_extended.
843 : : */
844 [ - + # # ]: 78 : if (hash_extended_proc == F_HASH_MULTIRANGE_EXTENDED &&
845 : 0 : !multirange_element_has_extended_hashing(typentry))
846 : 0 : hash_extended_proc = InvalidOid;
847 : :
848 : : /* Force update of proc finfo only if we're changing state */
849 [ + + ]: 78 : if (typentry->hash_extended_proc != hash_extended_proc)
850 : 63 : typentry->hash_extended_proc_finfo.fn_oid = InvalidOid;
851 : :
852 : 78 : typentry->hash_extended_proc = hash_extended_proc;
853 : 78 : typentry->flags |= TCFLAGS_CHECKED_HASH_EXTENDED_PROC;
854 : 78 : }
855 : :
856 : : /*
857 : : * Set up fmgr lookup info as requested
858 : : *
859 : : * Note: we tell fmgr the finfo structures live in CacheMemoryContext,
860 : : * which is not quite right (they're really in the hash table's private
861 : : * memory context) but this will do for our purposes.
862 : : *
863 : : * Note: the code above avoids invalidating the finfo structs unless the
864 : : * referenced operator/function OID actually changes. This is to prevent
865 : : * unnecessary leakage of any subsidiary data attached to an finfo, since
866 : : * that would cause session-lifespan memory leaks.
867 : : */
868 [ + + ]: 72684 : if ((flags & TYPECACHE_EQ_OPR_FINFO) &&
869 [ + + + + ]: 226 : typentry->eq_opr_finfo.fn_oid == InvalidOid &&
870 : 42 : typentry->eq_opr != InvalidOid)
871 : : {
872 : 41 : Oid eq_opr_func;
873 : :
874 : 41 : eq_opr_func = get_opcode(typentry->eq_opr);
875 [ + - ]: 41 : if (eq_opr_func != InvalidOid)
876 : 82 : fmgr_info_cxt(eq_opr_func, &typentry->eq_opr_finfo,
877 : 41 : CacheMemoryContext);
878 : 41 : }
879 [ + + ]: 72684 : if ((flags & TYPECACHE_CMP_PROC_FINFO) &&
880 [ + + + + ]: 659 : typentry->cmp_proc_finfo.fn_oid == InvalidOid &&
881 : 65 : typentry->cmp_proc != InvalidOid)
882 : : {
883 : 96 : fmgr_info_cxt(typentry->cmp_proc, &typentry->cmp_proc_finfo,
884 : 48 : CacheMemoryContext);
885 : 48 : }
886 [ + + ]: 72684 : if ((flags & TYPECACHE_HASH_PROC_FINFO) &&
887 [ + + + + ]: 100 : typentry->hash_proc_finfo.fn_oid == InvalidOid &&
888 : 29 : typentry->hash_proc != InvalidOid)
889 : : {
890 : 46 : fmgr_info_cxt(typentry->hash_proc, &typentry->hash_proc_finfo,
891 : 23 : CacheMemoryContext);
892 : 23 : }
893 [ + + ]: 72684 : if ((flags & TYPECACHE_HASH_EXTENDED_PROC_FINFO) &&
894 [ + + + + ]: 19 : typentry->hash_extended_proc_finfo.fn_oid == InvalidOid &&
895 : 6 : typentry->hash_extended_proc != InvalidOid)
896 : : {
897 : 8 : fmgr_info_cxt(typentry->hash_extended_proc,
898 : 4 : &typentry->hash_extended_proc_finfo,
899 : 4 : CacheMemoryContext);
900 : 4 : }
901 : :
902 : : /*
903 : : * If it's a composite type (row type), get tupdesc if requested
904 : : */
905 [ + + ]: 72684 : if ((flags & TYPECACHE_TUPDESC) &&
906 [ + + + + ]: 8797 : typentry->tupDesc == NULL &&
907 : 473 : typentry->typtype == TYPTYPE_COMPOSITE)
908 : : {
909 : 471 : load_typcache_tupdesc(typentry);
910 : 471 : }
911 : :
912 : : /*
913 : : * If requested, get information about a range type
914 : : *
915 : : * This includes making sure that the basic info about the range element
916 : : * type is up-to-date.
917 : : */
918 [ + + - + ]: 72684 : if ((flags & TYPECACHE_RANGE_INFO) &&
919 : 4545 : typentry->typtype == TYPTYPE_RANGE)
920 : : {
921 [ + + ]: 4545 : if (typentry->rngelemtype == NULL)
922 : 58 : load_rangetype_info(typentry);
923 [ + + ]: 4487 : else if (!(typentry->rngelemtype->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
924 : 1 : (void) lookup_type_cache(typentry->rngelemtype->type_id, 0);
925 : 4545 : }
926 : :
927 : : /*
928 : : * If requested, get information about a multirange type
929 : : */
930 [ + + ]: 72684 : if ((flags & TYPECACHE_MULTIRANGE_INFO) &&
931 [ + + - + ]: 2032 : typentry->rngtype == NULL &&
932 : 26 : typentry->typtype == TYPTYPE_MULTIRANGE)
933 : : {
934 : 26 : load_multirangetype_info(typentry);
935 : 26 : }
936 : :
937 : : /*
938 : : * If requested, get information about a domain type
939 : : */
940 [ + + ]: 72684 : if ((flags & TYPECACHE_DOMAIN_BASE_INFO) &&
941 [ + + + + ]: 1018 : typentry->domainBaseType == InvalidOid &&
942 : 638 : typentry->typtype == TYPTYPE_DOMAIN)
943 : : {
944 : 45 : typentry->domainBaseTypmod = -1;
945 : 45 : typentry->domainBaseType =
946 : 45 : getBaseTypeAndTypmod(type_id, &typentry->domainBaseTypmod);
947 : 45 : }
948 [ + + ]: 72684 : if ((flags & TYPECACHE_DOMAIN_CONSTR_INFO) &&
949 [ + + + + ]: 2636 : (typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
950 : 691 : typentry->typtype == TYPTYPE_DOMAIN)
951 : : {
952 : 359 : load_domaintype_info(typentry);
953 : 359 : }
954 : :
955 : : INJECTION_POINT("typecache-before-rel-type-cache-insert", NULL);
956 : :
957 [ + - ]: 72684 : Assert(in_progress_offset + 1 == in_progress_list_len);
958 : 72684 : in_progress_list_len--;
959 : :
960 : 72684 : insert_rel_type_cache_if_needed(typentry);
961 : :
962 : 145368 : return typentry;
963 : 72684 : }
964 : :
965 : : /*
966 : : * load_typcache_tupdesc --- helper routine to set up composite type's tupDesc
967 : : */
968 : : static void
969 : 490 : load_typcache_tupdesc(TypeCacheEntry *typentry)
970 : : {
971 : 490 : Relation rel;
972 : :
973 [ + - ]: 490 : if (!OidIsValid(typentry->typrelid)) /* should not happen */
974 [ # # # # ]: 0 : elog(ERROR, "invalid typrelid for composite type %u",
975 : : typentry->type_id);
976 : 490 : rel = relation_open(typentry->typrelid, AccessShareLock);
977 [ + - ]: 490 : Assert(rel->rd_rel->reltype == typentry->type_id);
978 : :
979 : : /*
980 : : * Link to the tupdesc and increment its refcount (we assert it's a
981 : : * refcounted descriptor). We don't use IncrTupleDescRefCount() for this,
982 : : * because the reference mustn't be entered in the current resource owner;
983 : : * it can outlive the current query.
984 : : */
985 : 490 : typentry->tupDesc = RelationGetDescr(rel);
986 : :
987 [ + - ]: 490 : Assert(typentry->tupDesc->tdrefcount > 0);
988 : 490 : typentry->tupDesc->tdrefcount++;
989 : :
990 : : /*
991 : : * In future, we could take some pains to not change tupDesc_identifier if
992 : : * the tupdesc didn't really change; but for now it's not worth it.
993 : : */
994 : 490 : typentry->tupDesc_identifier = ++tupledesc_id_counter;
995 : :
996 : 490 : relation_close(rel, AccessShareLock);
997 : 490 : }
998 : :
999 : : /*
1000 : : * load_rangetype_info --- helper routine to set up range type information
1001 : : */
1002 : : static void
1003 : 58 : load_rangetype_info(TypeCacheEntry *typentry)
1004 : : {
1005 : 58 : Form_pg_range pg_range;
1006 : 58 : HeapTuple tup;
1007 : 58 : Oid subtypeOid;
1008 : 58 : Oid opclassOid;
1009 : 58 : Oid canonicalOid;
1010 : 58 : Oid subdiffOid;
1011 : 58 : Oid opfamilyOid;
1012 : 58 : Oid opcintype;
1013 : 58 : Oid cmpFnOid;
1014 : :
1015 : : /* get information from pg_range */
1016 : 58 : tup = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(typentry->type_id));
1017 : : /* should not fail, since we already checked typtype ... */
1018 [ + - ]: 58 : if (!HeapTupleIsValid(tup))
1019 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for range type %u",
1020 : : typentry->type_id);
1021 : 58 : pg_range = (Form_pg_range) GETSTRUCT(tup);
1022 : :
1023 : 58 : subtypeOid = pg_range->rngsubtype;
1024 : 58 : typentry->rng_collation = pg_range->rngcollation;
1025 : 58 : opclassOid = pg_range->rngsubopc;
1026 : 58 : canonicalOid = pg_range->rngcanonical;
1027 : 58 : subdiffOid = pg_range->rngsubdiff;
1028 : :
1029 : 58 : ReleaseSysCache(tup);
1030 : :
1031 : : /* get opclass properties and look up the comparison function */
1032 : 58 : opfamilyOid = get_opclass_family(opclassOid);
1033 : 58 : opcintype = get_opclass_input_type(opclassOid);
1034 : 58 : typentry->rng_opfamily = opfamilyOid;
1035 : :
1036 : 58 : cmpFnOid = get_opfamily_proc(opfamilyOid, opcintype, opcintype,
1037 : : BTORDER_PROC);
1038 [ + - ]: 58 : if (!RegProcedureIsValid(cmpFnOid))
1039 [ # # # # ]: 0 : elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
1040 : : BTORDER_PROC, opcintype, opcintype, opfamilyOid);
1041 : :
1042 : : /* set up cached fmgrinfo structs */
1043 : 116 : fmgr_info_cxt(cmpFnOid, &typentry->rng_cmp_proc_finfo,
1044 : 58 : CacheMemoryContext);
1045 [ + + ]: 58 : if (OidIsValid(canonicalOid))
1046 : 44 : fmgr_info_cxt(canonicalOid, &typentry->rng_canonical_finfo,
1047 : 22 : CacheMemoryContext);
1048 [ + + ]: 58 : if (OidIsValid(subdiffOid))
1049 : 72 : fmgr_info_cxt(subdiffOid, &typentry->rng_subdiff_finfo,
1050 : 36 : CacheMemoryContext);
1051 : :
1052 : : /* Lastly, set up link to the element type --- this marks data valid */
1053 : 58 : typentry->rngelemtype = lookup_type_cache(subtypeOid, 0);
1054 : 58 : }
1055 : :
1056 : : /*
1057 : : * load_multirangetype_info --- helper routine to set up multirange type
1058 : : * information
1059 : : */
1060 : : static void
1061 : 26 : load_multirangetype_info(TypeCacheEntry *typentry)
1062 : : {
1063 : 26 : Oid rangetypeOid;
1064 : :
1065 : 26 : rangetypeOid = get_multirange_range(typentry->type_id);
1066 [ + - ]: 26 : if (!OidIsValid(rangetypeOid))
1067 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for multirange type %u",
1068 : : typentry->type_id);
1069 : :
1070 : 26 : typentry->rngtype = lookup_type_cache(rangetypeOid, TYPECACHE_RANGE_INFO);
1071 : 26 : }
1072 : :
1073 : : /*
1074 : : * load_domaintype_info --- helper routine to set up domain constraint info
1075 : : *
1076 : : * Note: we assume we're called in a relatively short-lived context, so it's
1077 : : * okay to leak data into the current context while scanning pg_constraint.
1078 : : * We build the new DomainConstraintCache data in a context underneath
1079 : : * CurrentMemoryContext, and reparent it under CacheMemoryContext when
1080 : : * complete.
1081 : : */
1082 : : static void
1083 : 359 : load_domaintype_info(TypeCacheEntry *typentry)
1084 : : {
1085 : 359 : Oid typeOid = typentry->type_id;
1086 : 359 : DomainConstraintCache *dcc;
1087 : 359 : bool notNull = false;
1088 : 359 : DomainConstraintState **ccons;
1089 : 359 : int cconslen;
1090 : 359 : Relation conRel;
1091 : 359 : MemoryContext oldcxt;
1092 : :
1093 : : /*
1094 : : * If we're here, any existing constraint info is stale, so release it.
1095 : : * For safety, be sure to null the link before trying to delete the data.
1096 : : */
1097 [ + + ]: 359 : if (typentry->domainData)
1098 : : {
1099 : 93 : dcc = typentry->domainData;
1100 : 93 : typentry->domainData = NULL;
1101 : 93 : decr_dcc_refcount(dcc);
1102 : 93 : }
1103 : :
1104 : : /*
1105 : : * We try to optimize the common case of no domain constraints, so don't
1106 : : * create the dcc object and context until we find a constraint. Likewise
1107 : : * for the temp sorting array.
1108 : : */
1109 : 359 : dcc = NULL;
1110 : 359 : ccons = NULL;
1111 : 359 : cconslen = 0;
1112 : :
1113 : : /*
1114 : : * Scan pg_constraint for relevant constraints. We want to find
1115 : : * constraints for not just this domain, but any ancestor domains, so the
1116 : : * outer loop crawls up the domain stack.
1117 : : */
1118 : 359 : conRel = table_open(ConstraintRelationId, AccessShareLock);
1119 : :
1120 : 722 : for (;;)
1121 : : {
1122 : 722 : HeapTuple tup;
1123 : 722 : HeapTuple conTup;
1124 : 722 : Form_pg_type typTup;
1125 : 722 : int nccons = 0;
1126 : 722 : ScanKeyData key[1];
1127 : 722 : SysScanDesc scan;
1128 : :
1129 : 722 : tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
1130 [ + - ]: 722 : if (!HeapTupleIsValid(tup))
1131 [ # # # # ]: 0 : elog(ERROR, "cache lookup failed for type %u", typeOid);
1132 : 722 : typTup = (Form_pg_type) GETSTRUCT(tup);
1133 : :
1134 [ + + ]: 722 : if (typTup->typtype != TYPTYPE_DOMAIN)
1135 : : {
1136 : : /* Not a domain, so done */
1137 : 359 : ReleaseSysCache(tup);
1138 : 359 : break;
1139 : : }
1140 : :
1141 : : /* Test for NOT NULL Constraint */
1142 [ + + ]: 363 : if (typTup->typnotnull)
1143 : 17 : notNull = true;
1144 : :
1145 : : /* Look for CHECK Constraints on this domain */
1146 : 726 : ScanKeyInit(&key[0],
1147 : : Anum_pg_constraint_contypid,
1148 : : BTEqualStrategyNumber, F_OIDEQ,
1149 : 363 : ObjectIdGetDatum(typeOid));
1150 : :
1151 : 726 : scan = systable_beginscan(conRel, ConstraintTypidIndexId, true,
1152 : 363 : NULL, 1, key);
1153 : :
1154 [ + + ]: 531 : while (HeapTupleIsValid(conTup = systable_getnext(scan)))
1155 : : {
1156 : 168 : Form_pg_constraint c = (Form_pg_constraint) GETSTRUCT(conTup);
1157 : 168 : Datum val;
1158 : 168 : bool isNull;
1159 : 168 : char *constring;
1160 : 168 : Expr *check_expr;
1161 : 168 : DomainConstraintState *r;
1162 : :
1163 : : /* Ignore non-CHECK constraints */
1164 [ + + ]: 168 : if (c->contype != CONSTRAINT_CHECK)
1165 : 17 : continue;
1166 : :
1167 : : /* Not expecting conbin to be NULL, but we'll test for it anyway */
1168 : 302 : val = fastgetattr(conTup, Anum_pg_constraint_conbin,
1169 : 151 : conRel->rd_att, &isNull);
1170 [ - + ]: 151 : if (isNull)
1171 [ # # # # ]: 0 : elog(ERROR, "domain \"%s\" constraint \"%s\" has NULL conbin",
1172 : : NameStr(typTup->typname), NameStr(c->conname));
1173 : :
1174 : : /* Create the DomainConstraintCache object and context if needed */
1175 [ + + ]: 151 : if (dcc == NULL)
1176 : : {
1177 : 147 : MemoryContext cxt;
1178 : :
1179 : 147 : cxt = AllocSetContextCreate(CurrentMemoryContext,
1180 : : "Domain constraints",
1181 : : ALLOCSET_SMALL_SIZES);
1182 : 147 : dcc = (DomainConstraintCache *)
1183 : 147 : MemoryContextAlloc(cxt, sizeof(DomainConstraintCache));
1184 : 147 : dcc->constraints = NIL;
1185 : 147 : dcc->dccContext = cxt;
1186 : 147 : dcc->dccRefCount = 0;
1187 : 147 : }
1188 : :
1189 : : /* Convert conbin to a node tree, still in caller's context */
1190 : 151 : constring = TextDatumGetCString(val);
1191 : 151 : check_expr = (Expr *) stringToNode(constring);
1192 : :
1193 : : /*
1194 : : * Plan the expression, since ExecInitExpr will expect that.
1195 : : *
1196 : : * Note: caching the result of expression_planner() is not very
1197 : : * good practice. Ideally we'd use a CachedExpression here so
1198 : : * that we would react promptly to, eg, changes in inlined
1199 : : * functions. However, because we don't support mutable domain
1200 : : * CHECK constraints, it's not really clear that it's worth the
1201 : : * extra overhead to do that.
1202 : : */
1203 : 151 : check_expr = expression_planner(check_expr);
1204 : :
1205 : : /* Create only the minimally needed stuff in dccContext */
1206 : 151 : oldcxt = MemoryContextSwitchTo(dcc->dccContext);
1207 : :
1208 : 151 : r = makeNode(DomainConstraintState);
1209 : 151 : r->constrainttype = DOM_CONSTRAINT_CHECK;
1210 : 151 : r->name = pstrdup(NameStr(c->conname));
1211 : 151 : r->check_expr = copyObject(check_expr);
1212 : 151 : r->check_exprstate = NULL;
1213 : :
1214 : 151 : MemoryContextSwitchTo(oldcxt);
1215 : :
1216 : : /* Accumulate constraints in an array, for sorting below */
1217 [ + + ]: 151 : if (ccons == NULL)
1218 : : {
1219 : 147 : cconslen = 8;
1220 : 147 : ccons = (DomainConstraintState **)
1221 : 147 : palloc(cconslen * sizeof(DomainConstraintState *));
1222 : 147 : }
1223 [ + - ]: 4 : else if (nccons >= cconslen)
1224 : : {
1225 : 0 : cconslen *= 2;
1226 : 0 : ccons = (DomainConstraintState **)
1227 : 0 : repalloc(ccons, cconslen * sizeof(DomainConstraintState *));
1228 : 0 : }
1229 : 151 : ccons[nccons++] = r;
1230 [ + + ]: 168 : }
1231 : :
1232 : 363 : systable_endscan(scan);
1233 : :
1234 [ + + ]: 363 : if (nccons > 0)
1235 : : {
1236 : : /*
1237 : : * Sort the items for this domain, so that CHECKs are applied in a
1238 : : * deterministic order.
1239 : : */
1240 [ + + ]: 149 : if (nccons > 1)
1241 : 2 : qsort(ccons, nccons, sizeof(DomainConstraintState *), dcs_cmp);
1242 : :
1243 : : /*
1244 : : * Now attach them to the overall list. Use lcons() here because
1245 : : * constraints of parent domains should be applied earlier.
1246 : : */
1247 : 149 : oldcxt = MemoryContextSwitchTo(dcc->dccContext);
1248 [ + + ]: 300 : while (nccons > 0)
1249 : 151 : dcc->constraints = lcons(ccons[--nccons], dcc->constraints);
1250 : 149 : MemoryContextSwitchTo(oldcxt);
1251 : 149 : }
1252 : :
1253 : : /* loop to next domain in stack */
1254 : 363 : typeOid = typTup->typbasetype;
1255 : 363 : ReleaseSysCache(tup);
1256 [ + + ]: 722 : }
1257 : :
1258 : 359 : table_close(conRel, AccessShareLock);
1259 : :
1260 : : /*
1261 : : * Only need to add one NOT NULL check regardless of how many domains in
1262 : : * the stack request it.
1263 : : */
1264 [ + + ]: 359 : if (notNull)
1265 : : {
1266 : 17 : DomainConstraintState *r;
1267 : :
1268 : : /* Create the DomainConstraintCache object and context if needed */
1269 [ + + ]: 17 : if (dcc == NULL)
1270 : : {
1271 : 15 : MemoryContext cxt;
1272 : :
1273 : 15 : cxt = AllocSetContextCreate(CurrentMemoryContext,
1274 : : "Domain constraints",
1275 : : ALLOCSET_SMALL_SIZES);
1276 : 15 : dcc = (DomainConstraintCache *)
1277 : 15 : MemoryContextAlloc(cxt, sizeof(DomainConstraintCache));
1278 : 15 : dcc->constraints = NIL;
1279 : 15 : dcc->dccContext = cxt;
1280 : 15 : dcc->dccRefCount = 0;
1281 : 15 : }
1282 : :
1283 : : /* Create node trees in DomainConstraintCache's context */
1284 : 17 : oldcxt = MemoryContextSwitchTo(dcc->dccContext);
1285 : :
1286 : 17 : r = makeNode(DomainConstraintState);
1287 : :
1288 : 17 : r->constrainttype = DOM_CONSTRAINT_NOTNULL;
1289 : 17 : r->name = pstrdup("NOT NULL");
1290 : 17 : r->check_expr = NULL;
1291 : 17 : r->check_exprstate = NULL;
1292 : :
1293 : : /* lcons to apply the nullness check FIRST */
1294 : 17 : dcc->constraints = lcons(r, dcc->constraints);
1295 : :
1296 : 17 : MemoryContextSwitchTo(oldcxt);
1297 : 17 : }
1298 : :
1299 : : /*
1300 : : * If we made a constraint object, move it into CacheMemoryContext and
1301 : : * attach it to the typcache entry.
1302 : : */
1303 [ + + ]: 359 : if (dcc)
1304 : : {
1305 : 162 : MemoryContextSetParent(dcc->dccContext, CacheMemoryContext);
1306 : 162 : typentry->domainData = dcc;
1307 : 162 : dcc->dccRefCount++; /* count the typcache's reference */
1308 : 162 : }
1309 : :
1310 : : /* Either way, the typcache entry's domain data is now valid. */
1311 : 359 : typentry->flags |= TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS;
1312 : 359 : }
1313 : :
1314 : : /*
1315 : : * qsort comparator to sort DomainConstraintState pointers by name
1316 : : */
1317 : : static int
1318 : 2 : dcs_cmp(const void *a, const void *b)
1319 : : {
1320 : 2 : const DomainConstraintState *const *ca = (const DomainConstraintState *const *) a;
1321 : 2 : const DomainConstraintState *const *cb = (const DomainConstraintState *const *) b;
1322 : :
1323 : 4 : return strcmp((*ca)->name, (*cb)->name);
1324 : 2 : }
1325 : :
1326 : : /*
1327 : : * decr_dcc_refcount --- decrement a DomainConstraintCache's refcount,
1328 : : * and free it if no references remain
1329 : : */
1330 : : static void
1331 : 936 : decr_dcc_refcount(DomainConstraintCache *dcc)
1332 : : {
1333 [ + - ]: 936 : Assert(dcc->dccRefCount > 0);
1334 [ + + ]: 936 : if (--(dcc->dccRefCount) <= 0)
1335 : 93 : MemoryContextDelete(dcc->dccContext);
1336 : 936 : }
1337 : :
1338 : : /*
1339 : : * Context reset/delete callback for a DomainConstraintRef
1340 : : */
1341 : : static void
1342 : 885 : dccref_deletion_callback(void *arg)
1343 : : {
1344 : 885 : DomainConstraintRef *ref = (DomainConstraintRef *) arg;
1345 : 885 : DomainConstraintCache *dcc = ref->dcc;
1346 : :
1347 : : /* Paranoia --- be sure link is nulled before trying to release */
1348 [ + + ]: 885 : if (dcc)
1349 : : {
1350 : 843 : ref->constraints = NIL;
1351 : 843 : ref->dcc = NULL;
1352 : 843 : decr_dcc_refcount(dcc);
1353 : 843 : }
1354 : 885 : }
1355 : :
1356 : : /*
1357 : : * prep_domain_constraints --- prepare domain constraints for execution
1358 : : *
1359 : : * The expression trees stored in the DomainConstraintCache's list are
1360 : : * converted to executable expression state trees stored in execctx.
1361 : : */
1362 : : static List *
1363 : 383 : prep_domain_constraints(List *constraints, MemoryContext execctx)
1364 : : {
1365 : 383 : List *result = NIL;
1366 : 383 : MemoryContext oldcxt;
1367 : 383 : ListCell *lc;
1368 : :
1369 : 383 : oldcxt = MemoryContextSwitchTo(execctx);
1370 : :
1371 [ + - + + : 770 : foreach(lc, constraints)
+ + ]
1372 : : {
1373 : 387 : DomainConstraintState *r = (DomainConstraintState *) lfirst(lc);
1374 : 387 : DomainConstraintState *newr;
1375 : :
1376 : 387 : newr = makeNode(DomainConstraintState);
1377 : 387 : newr->constrainttype = r->constrainttype;
1378 : 387 : newr->name = r->name;
1379 : 387 : newr->check_expr = r->check_expr;
1380 : 387 : newr->check_exprstate = ExecInitExpr(r->check_expr, NULL);
1381 : :
1382 : 387 : result = lappend(result, newr);
1383 : 387 : }
1384 : :
1385 : 383 : MemoryContextSwitchTo(oldcxt);
1386 : :
1387 : 766 : return result;
1388 : 383 : }
1389 : :
1390 : : /*
1391 : : * InitDomainConstraintRef --- initialize a DomainConstraintRef struct
1392 : : *
1393 : : * Caller must tell us the MemoryContext in which the DomainConstraintRef
1394 : : * lives. The ref will be cleaned up when that context is reset/deleted.
1395 : : *
1396 : : * Caller must also tell us whether it wants check_exprstate fields to be
1397 : : * computed in the DomainConstraintState nodes attached to this ref.
1398 : : * If it doesn't, we need not make a copy of the DomainConstraintState list.
1399 : : */
1400 : : void
1401 : 885 : InitDomainConstraintRef(Oid type_id, DomainConstraintRef *ref,
1402 : : MemoryContext refctx, bool need_exprstate)
1403 : : {
1404 : : /* Look up the typcache entry --- we assume it survives indefinitely */
1405 : 885 : ref->tcache = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
1406 : 885 : ref->need_exprstate = need_exprstate;
1407 : : /* For safety, establish the callback before acquiring a refcount */
1408 : 885 : ref->refctx = refctx;
1409 : 885 : ref->dcc = NULL;
1410 : 885 : ref->callback.func = dccref_deletion_callback;
1411 : 885 : ref->callback.arg = ref;
1412 : 885 : MemoryContextRegisterResetCallback(refctx, &ref->callback);
1413 : : /* Acquire refcount if there are constraints, and set up exported list */
1414 [ + + ]: 885 : if (ref->tcache->domainData)
1415 : : {
1416 : 843 : ref->dcc = ref->tcache->domainData;
1417 : 843 : ref->dcc->dccRefCount++;
1418 [ + + ]: 843 : if (ref->need_exprstate)
1419 : 766 : ref->constraints = prep_domain_constraints(ref->dcc->constraints,
1420 : 383 : ref->refctx);
1421 : : else
1422 : 460 : ref->constraints = ref->dcc->constraints;
1423 : 843 : }
1424 : : else
1425 : 42 : ref->constraints = NIL;
1426 : 885 : }
1427 : :
1428 : : /*
1429 : : * UpdateDomainConstraintRef --- recheck validity of domain constraint info
1430 : : *
1431 : : * If the domain's constraint set changed, ref->constraints is updated to
1432 : : * point at a new list of cached constraints.
1433 : : *
1434 : : * In the normal case where nothing happened to the domain, this is cheap
1435 : : * enough that it's reasonable (and expected) to check before *each* use
1436 : : * of the constraint info.
1437 : : */
1438 : : void
1439 : 5108 : UpdateDomainConstraintRef(DomainConstraintRef *ref)
1440 : : {
1441 : 5108 : TypeCacheEntry *typentry = ref->tcache;
1442 : :
1443 : : /* Make sure typcache entry's data is up to date */
1444 [ - + # # ]: 5108 : if ((typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
1445 : 0 : typentry->typtype == TYPTYPE_DOMAIN)
1446 : 0 : load_domaintype_info(typentry);
1447 : :
1448 : : /* Transfer to ref object if there's new info, adjusting refcounts */
1449 [ + - ]: 5108 : if (ref->dcc != typentry->domainData)
1450 : : {
1451 : : /* Paranoia --- be sure link is nulled before trying to release */
1452 : 0 : DomainConstraintCache *dcc = ref->dcc;
1453 : :
1454 [ # # ]: 0 : if (dcc)
1455 : : {
1456 : : /*
1457 : : * Note: we just leak the previous list of executable domain
1458 : : * constraints. Alternatively, we could keep those in a child
1459 : : * context of ref->refctx and free that context at this point.
1460 : : * However, in practice this code path will be taken so seldom
1461 : : * that the extra bookkeeping for a child context doesn't seem
1462 : : * worthwhile; we'll just allow a leak for the lifespan of refctx.
1463 : : */
1464 : 0 : ref->constraints = NIL;
1465 : 0 : ref->dcc = NULL;
1466 : 0 : decr_dcc_refcount(dcc);
1467 : 0 : }
1468 : 0 : dcc = typentry->domainData;
1469 [ # # ]: 0 : if (dcc)
1470 : : {
1471 : 0 : ref->dcc = dcc;
1472 : 0 : dcc->dccRefCount++;
1473 [ # # ]: 0 : if (ref->need_exprstate)
1474 : 0 : ref->constraints = prep_domain_constraints(dcc->constraints,
1475 : 0 : ref->refctx);
1476 : : else
1477 : 0 : ref->constraints = dcc->constraints;
1478 : 0 : }
1479 : 0 : }
1480 : 5108 : }
1481 : :
1482 : : /*
1483 : : * DomainHasConstraints --- utility routine to check if a domain has constraints
1484 : : *
1485 : : * This is defined to return false, not fail, if type is not a domain.
1486 : : */
1487 : : bool
1488 : 1751 : DomainHasConstraints(Oid type_id)
1489 : : {
1490 : 1751 : TypeCacheEntry *typentry;
1491 : :
1492 : : /*
1493 : : * Note: a side effect is to cause the typcache's domain data to become
1494 : : * valid. This is fine since we'll likely need it soon if there is any.
1495 : : */
1496 : 1751 : typentry = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
1497 : :
1498 : 3502 : return (typentry->domainData != NULL);
1499 : 1751 : }
1500 : :
1501 : :
1502 : : /*
1503 : : * array_element_has_equality and friends are helper routines to check
1504 : : * whether we should believe that array_eq and related functions will work
1505 : : * on the given array type or composite type.
1506 : : *
1507 : : * The logic above may call these repeatedly on the same type entry, so we
1508 : : * make use of the typentry->flags field to cache the results once known.
1509 : : * Also, we assume that we'll probably want all these facts about the type
1510 : : * if we want any, so we cache them all using only one lookup of the
1511 : : * component datatype(s).
1512 : : */
1513 : :
1514 : : static bool
1515 : 36 : array_element_has_equality(TypeCacheEntry *typentry)
1516 : : {
1517 [ + + ]: 36 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1518 : 34 : cache_array_element_properties(typentry);
1519 : 36 : return (typentry->flags & TCFLAGS_HAVE_ELEM_EQUALITY) != 0;
1520 : : }
1521 : :
1522 : : static bool
1523 : 65 : array_element_has_compare(TypeCacheEntry *typentry)
1524 : : {
1525 [ + + ]: 65 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1526 : 7 : cache_array_element_properties(typentry);
1527 : 65 : return (typentry->flags & TCFLAGS_HAVE_ELEM_COMPARE) != 0;
1528 : : }
1529 : :
1530 : : static bool
1531 : 20 : array_element_has_hashing(TypeCacheEntry *typentry)
1532 : : {
1533 [ + - ]: 20 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1534 : 0 : cache_array_element_properties(typentry);
1535 : 20 : return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
1536 : : }
1537 : :
1538 : : static bool
1539 : 4 : array_element_has_extended_hashing(TypeCacheEntry *typentry)
1540 : : {
1541 [ + - ]: 4 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1542 : 0 : cache_array_element_properties(typentry);
1543 : 4 : return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
1544 : : }
1545 : :
1546 : : static void
1547 : 41 : cache_array_element_properties(TypeCacheEntry *typentry)
1548 : : {
1549 : 41 : Oid elem_type = get_base_element_type(typentry->type_id);
1550 : :
1551 [ + + ]: 41 : if (OidIsValid(elem_type))
1552 : : {
1553 : 39 : TypeCacheEntry *elementry;
1554 : :
1555 : 39 : elementry = lookup_type_cache(elem_type,
1556 : : TYPECACHE_EQ_OPR |
1557 : : TYPECACHE_CMP_PROC |
1558 : : TYPECACHE_HASH_PROC |
1559 : : TYPECACHE_HASH_EXTENDED_PROC);
1560 [ + + ]: 39 : if (OidIsValid(elementry->eq_opr))
1561 : 37 : typentry->flags |= TCFLAGS_HAVE_ELEM_EQUALITY;
1562 [ + + ]: 39 : if (OidIsValid(elementry->cmp_proc))
1563 : 36 : typentry->flags |= TCFLAGS_HAVE_ELEM_COMPARE;
1564 [ + + ]: 39 : if (OidIsValid(elementry->hash_proc))
1565 : 35 : typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
1566 [ + + ]: 39 : if (OidIsValid(elementry->hash_extended_proc))
1567 : 35 : typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
1568 : 39 : }
1569 : 41 : typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
1570 : 41 : }
1571 : :
1572 : : /*
1573 : : * Likewise, some helper functions for composite types.
1574 : : */
1575 : :
1576 : : static bool
1577 : 33 : record_fields_have_equality(TypeCacheEntry *typentry)
1578 : : {
1579 [ + + ]: 33 : if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
1580 : 28 : cache_record_field_properties(typentry);
1581 : 33 : return (typentry->flags & TCFLAGS_HAVE_FIELD_EQUALITY) != 0;
1582 : : }
1583 : :
1584 : : static bool
1585 : 40 : record_fields_have_compare(TypeCacheEntry *typentry)
1586 : : {
1587 [ + + ]: 40 : if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
1588 : 10 : cache_record_field_properties(typentry);
1589 : 40 : return (typentry->flags & TCFLAGS_HAVE_FIELD_COMPARE) != 0;
1590 : : }
1591 : :
1592 : : static bool
1593 : 31 : record_fields_have_hashing(TypeCacheEntry *typentry)
1594 : : {
1595 [ + + ]: 31 : if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
1596 : 1 : cache_record_field_properties(typentry);
1597 : 31 : return (typentry->flags & TCFLAGS_HAVE_FIELD_HASHING) != 0;
1598 : : }
1599 : :
1600 : : static bool
1601 : 3 : record_fields_have_extended_hashing(TypeCacheEntry *typentry)
1602 : : {
1603 [ + - ]: 3 : if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
1604 : 0 : cache_record_field_properties(typentry);
1605 : 3 : return (typentry->flags & TCFLAGS_HAVE_FIELD_EXTENDED_HASHING) != 0;
1606 : : }
1607 : :
1608 : : static void
1609 : 39 : cache_record_field_properties(TypeCacheEntry *typentry)
1610 : : {
1611 : : /*
1612 : : * For type RECORD, we can't really tell what will work, since we don't
1613 : : * have access here to the specific anonymous type. Just assume that
1614 : : * equality and comparison will (we may get a failure at runtime). We
1615 : : * could also claim that hashing works, but then if code that has the
1616 : : * option between a comparison-based (sort-based) and a hash-based plan
1617 : : * chooses hashing, stuff could fail that would otherwise work if it chose
1618 : : * a comparison-based plan. In practice more types support comparison
1619 : : * than hashing.
1620 : : */
1621 [ + + ]: 39 : if (typentry->type_id == RECORDOID)
1622 : : {
1623 : 8 : typentry->flags |= (TCFLAGS_HAVE_FIELD_EQUALITY |
1624 : : TCFLAGS_HAVE_FIELD_COMPARE);
1625 : 8 : }
1626 [ + - ]: 31 : else if (typentry->typtype == TYPTYPE_COMPOSITE)
1627 : : {
1628 : 31 : TupleDesc tupdesc;
1629 : 31 : int newflags;
1630 : 31 : int i;
1631 : :
1632 : : /* Fetch composite type's tupdesc if we don't have it already */
1633 [ + + ]: 31 : if (typentry->tupDesc == NULL)
1634 : 19 : load_typcache_tupdesc(typentry);
1635 : 31 : tupdesc = typentry->tupDesc;
1636 : :
1637 : : /* Must bump the refcount while we do additional catalog lookups */
1638 : 31 : IncrTupleDescRefCount(tupdesc);
1639 : :
1640 : : /* Have each property if all non-dropped fields have the property */
1641 : 31 : newflags = (TCFLAGS_HAVE_FIELD_EQUALITY |
1642 : : TCFLAGS_HAVE_FIELD_COMPARE |
1643 : : TCFLAGS_HAVE_FIELD_HASHING |
1644 : : TCFLAGS_HAVE_FIELD_EXTENDED_HASHING);
1645 [ + + ]: 142 : for (i = 0; i < tupdesc->natts; i++)
1646 : : {
1647 : 116 : TypeCacheEntry *fieldentry;
1648 : 116 : Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
1649 : :
1650 [ - + ]: 116 : if (attr->attisdropped)
1651 : 0 : continue;
1652 : :
1653 : 116 : fieldentry = lookup_type_cache(attr->atttypid,
1654 : : TYPECACHE_EQ_OPR |
1655 : : TYPECACHE_CMP_PROC |
1656 : : TYPECACHE_HASH_PROC |
1657 : : TYPECACHE_HASH_EXTENDED_PROC);
1658 [ + + ]: 116 : if (!OidIsValid(fieldentry->eq_opr))
1659 : 5 : newflags &= ~TCFLAGS_HAVE_FIELD_EQUALITY;
1660 [ + + ]: 116 : if (!OidIsValid(fieldentry->cmp_proc))
1661 : 5 : newflags &= ~TCFLAGS_HAVE_FIELD_COMPARE;
1662 [ + + ]: 116 : if (!OidIsValid(fieldentry->hash_proc))
1663 : 6 : newflags &= ~TCFLAGS_HAVE_FIELD_HASHING;
1664 [ + + ]: 116 : if (!OidIsValid(fieldentry->hash_extended_proc))
1665 : 6 : newflags &= ~TCFLAGS_HAVE_FIELD_EXTENDED_HASHING;
1666 : :
1667 : : /* We can drop out of the loop once we disprove all bits */
1668 [ + + ]: 116 : if (newflags == 0)
1669 : 5 : break;
1670 [ - - + + ]: 116 : }
1671 : 31 : typentry->flags |= newflags;
1672 : :
1673 : 31 : DecrTupleDescRefCount(tupdesc);
1674 : 31 : }
1675 [ # # ]: 0 : else if (typentry->typtype == TYPTYPE_DOMAIN)
1676 : : {
1677 : : /* If it's domain over composite, copy base type's properties */
1678 : 0 : TypeCacheEntry *baseentry;
1679 : :
1680 : : /* load up basetype info if we didn't already */
1681 [ # # ]: 0 : if (typentry->domainBaseType == InvalidOid)
1682 : : {
1683 : 0 : typentry->domainBaseTypmod = -1;
1684 : 0 : typentry->domainBaseType =
1685 : 0 : getBaseTypeAndTypmod(typentry->type_id,
1686 : 0 : &typentry->domainBaseTypmod);
1687 : 0 : }
1688 : 0 : baseentry = lookup_type_cache(typentry->domainBaseType,
1689 : : TYPECACHE_EQ_OPR |
1690 : : TYPECACHE_CMP_PROC |
1691 : : TYPECACHE_HASH_PROC |
1692 : : TYPECACHE_HASH_EXTENDED_PROC);
1693 [ # # ]: 0 : if (baseentry->typtype == TYPTYPE_COMPOSITE)
1694 : : {
1695 : 0 : typentry->flags |= TCFLAGS_DOMAIN_BASE_IS_COMPOSITE;
1696 : 0 : typentry->flags |= baseentry->flags & (TCFLAGS_HAVE_FIELD_EQUALITY |
1697 : : TCFLAGS_HAVE_FIELD_COMPARE |
1698 : : TCFLAGS_HAVE_FIELD_HASHING |
1699 : : TCFLAGS_HAVE_FIELD_EXTENDED_HASHING);
1700 : 0 : }
1701 : 0 : }
1702 : 39 : typentry->flags |= TCFLAGS_CHECKED_FIELD_PROPERTIES;
1703 : 39 : }
1704 : :
1705 : : /*
1706 : : * Likewise, some helper functions for range and multirange types.
1707 : : *
1708 : : * We can borrow the flag bits for array element properties to use for range
1709 : : * element properties, since those flag bits otherwise have no use in a
1710 : : * range or multirange type's typcache entry.
1711 : : */
1712 : :
1713 : : static bool
1714 : 5 : range_element_has_hashing(TypeCacheEntry *typentry)
1715 : : {
1716 [ - + ]: 5 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1717 : 5 : cache_range_element_properties(typentry);
1718 : 5 : return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
1719 : : }
1720 : :
1721 : : static bool
1722 : 0 : range_element_has_extended_hashing(TypeCacheEntry *typentry)
1723 : : {
1724 [ # # ]: 0 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1725 : 0 : cache_range_element_properties(typentry);
1726 : 0 : return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
1727 : : }
1728 : :
1729 : : static void
1730 : 5 : cache_range_element_properties(TypeCacheEntry *typentry)
1731 : : {
1732 : : /* load up subtype link if we didn't already */
1733 [ - + # # ]: 5 : if (typentry->rngelemtype == NULL &&
1734 : 0 : typentry->typtype == TYPTYPE_RANGE)
1735 : 0 : load_rangetype_info(typentry);
1736 : :
1737 [ - + ]: 5 : if (typentry->rngelemtype != NULL)
1738 : : {
1739 : 5 : TypeCacheEntry *elementry;
1740 : :
1741 : : /* might need to calculate subtype's hash function properties */
1742 : 5 : elementry = lookup_type_cache(typentry->rngelemtype->type_id,
1743 : : TYPECACHE_HASH_PROC |
1744 : : TYPECACHE_HASH_EXTENDED_PROC);
1745 [ + + ]: 5 : if (OidIsValid(elementry->hash_proc))
1746 : 4 : typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
1747 [ + + ]: 5 : if (OidIsValid(elementry->hash_extended_proc))
1748 : 4 : typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
1749 : 5 : }
1750 : 5 : typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
1751 : 5 : }
1752 : :
1753 : : static bool
1754 : 3 : multirange_element_has_hashing(TypeCacheEntry *typentry)
1755 : : {
1756 [ - + ]: 3 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1757 : 3 : cache_multirange_element_properties(typentry);
1758 : 3 : return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
1759 : : }
1760 : :
1761 : : static bool
1762 : 0 : multirange_element_has_extended_hashing(TypeCacheEntry *typentry)
1763 : : {
1764 [ # # ]: 0 : if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
1765 : 0 : cache_multirange_element_properties(typentry);
1766 : 0 : return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
1767 : : }
1768 : :
1769 : : static void
1770 : 3 : cache_multirange_element_properties(TypeCacheEntry *typentry)
1771 : : {
1772 : : /* load up range link if we didn't already */
1773 [ - + # # ]: 3 : if (typentry->rngtype == NULL &&
1774 : 0 : typentry->typtype == TYPTYPE_MULTIRANGE)
1775 : 0 : load_multirangetype_info(typentry);
1776 : :
1777 [ + - - + ]: 3 : if (typentry->rngtype != NULL && typentry->rngtype->rngelemtype != NULL)
1778 : : {
1779 : 3 : TypeCacheEntry *elementry;
1780 : :
1781 : : /* might need to calculate subtype's hash function properties */
1782 : 3 : elementry = lookup_type_cache(typentry->rngtype->rngelemtype->type_id,
1783 : : TYPECACHE_HASH_PROC |
1784 : : TYPECACHE_HASH_EXTENDED_PROC);
1785 [ + + ]: 3 : if (OidIsValid(elementry->hash_proc))
1786 : 2 : typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
1787 [ + + ]: 3 : if (OidIsValid(elementry->hash_extended_proc))
1788 : 2 : typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
1789 : 3 : }
1790 : 3 : typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
1791 : 3 : }
1792 : :
1793 : : /*
1794 : : * Make sure that RecordCacheArray and RecordIdentifierArray are large enough
1795 : : * to store 'typmod'.
1796 : : */
1797 : : static void
1798 : 474 : ensure_record_cache_typmod_slot_exists(int32 typmod)
1799 : : {
1800 [ + + ]: 474 : if (RecordCacheArray == NULL)
1801 : : {
1802 : 145 : RecordCacheArray = (RecordCacheArrayEntry *)
1803 : 145 : MemoryContextAllocZero(CacheMemoryContext,
1804 : : 64 * sizeof(RecordCacheArrayEntry));
1805 : 145 : RecordCacheArrayLen = 64;
1806 : 145 : }
1807 : :
1808 [ + - ]: 474 : if (typmod >= RecordCacheArrayLen)
1809 : : {
1810 : 0 : int32 newlen = pg_nextpower2_32(typmod + 1);
1811 : :
1812 : 0 : RecordCacheArray = repalloc0_array(RecordCacheArray,
1813 : : RecordCacheArrayEntry,
1814 : : RecordCacheArrayLen,
1815 : : newlen);
1816 : 0 : RecordCacheArrayLen = newlen;
1817 : 0 : }
1818 : 474 : }
1819 : :
1820 : : /*
1821 : : * lookup_rowtype_tupdesc_internal --- internal routine to lookup a rowtype
1822 : : *
1823 : : * Same API as lookup_rowtype_tupdesc_noerror, but the returned tupdesc
1824 : : * hasn't had its refcount bumped.
1825 : : */
1826 : : static TupleDesc
1827 : 11138 : lookup_rowtype_tupdesc_internal(Oid type_id, int32 typmod, bool noError)
1828 : : {
1829 [ + + ]: 11138 : if (type_id != RECORDOID)
1830 : : {
1831 : : /*
1832 : : * It's a named composite type, so use the regular typcache.
1833 : : */
1834 : 4862 : TypeCacheEntry *typentry;
1835 : :
1836 : 4862 : typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
1837 [ - + # # ]: 4862 : if (typentry->tupDesc == NULL && !noError)
1838 [ # # # # ]: 0 : ereport(ERROR,
1839 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1840 : : errmsg("type %s is not composite",
1841 : : format_type_be(type_id))));
1842 : 4862 : return typentry->tupDesc;
1843 : 4862 : }
1844 : : else
1845 : : {
1846 : : /*
1847 : : * It's a transient record type, so look in our record-type table.
1848 : : */
1849 [ - + ]: 6276 : if (typmod >= 0)
1850 : : {
1851 : : /* It is already in our local cache? */
1852 [ + + + + ]: 6276 : if (typmod < RecordCacheArrayLen &&
1853 : 6275 : RecordCacheArray[typmod].tupdesc != NULL)
1854 : 6271 : return RecordCacheArray[typmod].tupdesc;
1855 : :
1856 : : /* Are we attached to a shared record typmod registry? */
1857 [ - + ]: 5 : if (CurrentSession->shared_typmod_registry != NULL)
1858 : : {
1859 : 5 : SharedTypmodTableEntry *entry;
1860 : :
1861 : : /* Try to find it in the shared typmod index. */
1862 : 5 : entry = dshash_find(CurrentSession->shared_typmod_table,
1863 : : &typmod, false);
1864 [ + - ]: 5 : if (entry != NULL)
1865 : : {
1866 : 5 : TupleDesc tupdesc;
1867 : :
1868 : 5 : tupdesc = (TupleDesc)
1869 : 10 : dsa_get_address(CurrentSession->area,
1870 : 5 : entry->shared_tupdesc);
1871 [ + - ]: 5 : Assert(typmod == tupdesc->tdtypmod);
1872 : :
1873 : : /* We may need to extend the local RecordCacheArray. */
1874 : 5 : ensure_record_cache_typmod_slot_exists(typmod);
1875 : :
1876 : : /*
1877 : : * Our local array can now point directly to the TupleDesc
1878 : : * in shared memory, which is non-reference-counted.
1879 : : */
1880 : 5 : RecordCacheArray[typmod].tupdesc = tupdesc;
1881 [ + - ]: 5 : Assert(tupdesc->tdrefcount == -1);
1882 : :
1883 : : /*
1884 : : * We don't share tupdesc identifiers across processes, so
1885 : : * assign one locally.
1886 : : */
1887 : 5 : RecordCacheArray[typmod].id = ++tupledesc_id_counter;
1888 : :
1889 : 10 : dshash_release_lock(CurrentSession->shared_typmod_table,
1890 : 5 : entry);
1891 : :
1892 : 5 : return RecordCacheArray[typmod].tupdesc;
1893 : 5 : }
1894 [ - + - ]: 5 : }
1895 : 0 : }
1896 : :
1897 [ # # ]: 0 : if (!noError)
1898 [ # # # # ]: 0 : ereport(ERROR,
1899 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1900 : : errmsg("record type has not been registered")));
1901 : 0 : return NULL;
1902 : : }
1903 : 11138 : }
1904 : :
1905 : : /*
1906 : : * lookup_rowtype_tupdesc
1907 : : *
1908 : : * Given a typeid/typmod that should describe a known composite type,
1909 : : * return the tuple descriptor for the type. Will ereport on failure.
1910 : : * (Use ereport because this is reachable with user-specified OIDs,
1911 : : * for example from record_in().)
1912 : : *
1913 : : * Note: on success, we increment the refcount of the returned TupleDesc,
1914 : : * and log the reference in CurrentResourceOwner. Caller must call
1915 : : * ReleaseTupleDesc when done using the tupdesc. (There are some
1916 : : * cases in which the returned tupdesc is not refcounted, in which
1917 : : * case PinTupleDesc/ReleaseTupleDesc are no-ops; but in these cases
1918 : : * the tupdesc is guaranteed to live till process exit.)
1919 : : */
1920 : : TupleDesc
1921 : 7653 : lookup_rowtype_tupdesc(Oid type_id, int32 typmod)
1922 : : {
1923 : 7653 : TupleDesc tupDesc;
1924 : :
1925 : 7653 : tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
1926 [ + + ]: 7653 : PinTupleDesc(tupDesc);
1927 : 15306 : return tupDesc;
1928 : 7653 : }
1929 : :
1930 : : /*
1931 : : * lookup_rowtype_tupdesc_noerror
1932 : : *
1933 : : * As above, but if the type is not a known composite type and noError
1934 : : * is true, returns NULL instead of ereport'ing. (Note that if a bogus
1935 : : * type_id is passed, you'll get an ereport anyway.)
1936 : : */
1937 : : TupleDesc
1938 : 2 : lookup_rowtype_tupdesc_noerror(Oid type_id, int32 typmod, bool noError)
1939 : : {
1940 : 2 : TupleDesc tupDesc;
1941 : :
1942 : 2 : tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
1943 [ - + ]: 2 : if (tupDesc != NULL)
1944 [ - + ]: 2 : PinTupleDesc(tupDesc);
1945 : 4 : return tupDesc;
1946 : 2 : }
1947 : :
1948 : : /*
1949 : : * lookup_rowtype_tupdesc_copy
1950 : : *
1951 : : * Like lookup_rowtype_tupdesc(), but the returned TupleDesc has been
1952 : : * copied into the CurrentMemoryContext and is not reference-counted.
1953 : : */
1954 : : TupleDesc
1955 : 3483 : lookup_rowtype_tupdesc_copy(Oid type_id, int32 typmod)
1956 : : {
1957 : 3483 : TupleDesc tmp;
1958 : :
1959 : 3483 : tmp = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
1960 : 6966 : return CreateTupleDescCopyConstr(tmp);
1961 : 3483 : }
1962 : :
1963 : : /*
1964 : : * lookup_rowtype_tupdesc_domain
1965 : : *
1966 : : * Same as lookup_rowtype_tupdesc_noerror(), except that the type can also be
1967 : : * a domain over a named composite type; so this is effectively equivalent to
1968 : : * lookup_rowtype_tupdesc_noerror(getBaseType(type_id), typmod, noError)
1969 : : * except for being a tad faster.
1970 : : *
1971 : : * Note: the reason we don't fold the look-through-domain behavior into plain
1972 : : * lookup_rowtype_tupdesc() is that we want callers to know they might be
1973 : : * dealing with a domain. Otherwise they might construct a tuple that should
1974 : : * be of the domain type, but not apply domain constraints.
1975 : : */
1976 : : TupleDesc
1977 : 434 : lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, bool noError)
1978 : : {
1979 : 434 : TupleDesc tupDesc;
1980 : :
1981 [ + - ]: 434 : if (type_id != RECORDOID)
1982 : : {
1983 : : /*
1984 : : * Check for domain or named composite type. We might as well load
1985 : : * whichever data is needed.
1986 : : */
1987 : 434 : TypeCacheEntry *typentry;
1988 : :
1989 : 434 : typentry = lookup_type_cache(type_id,
1990 : : TYPECACHE_TUPDESC |
1991 : : TYPECACHE_DOMAIN_BASE_INFO);
1992 [ + + ]: 434 : if (typentry->typtype == TYPTYPE_DOMAIN)
1993 : 4 : return lookup_rowtype_tupdesc_noerror(typentry->domainBaseType,
1994 : 2 : typentry->domainBaseTypmod,
1995 : 2 : noError);
1996 [ - + # # ]: 432 : if (typentry->tupDesc == NULL && !noError)
1997 [ # # # # ]: 0 : ereport(ERROR,
1998 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1999 : : errmsg("type %s is not composite",
2000 : : format_type_be(type_id))));
2001 : 432 : tupDesc = typentry->tupDesc;
2002 [ + + ]: 434 : }
2003 : : else
2004 : 0 : tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
2005 [ - + ]: 432 : if (tupDesc != NULL)
2006 [ - + ]: 432 : PinTupleDesc(tupDesc);
2007 : 432 : return tupDesc;
2008 : 434 : }
2009 : :
2010 : : /*
2011 : : * Hash function for the hash table of RecordCacheEntry.
2012 : : */
2013 : : static uint32
2014 : 14524 : record_type_typmod_hash(const void *data, size_t size)
2015 : : {
2016 : 14524 : const RecordCacheEntry *entry = data;
2017 : :
2018 : 29048 : return hashRowType(entry->tupdesc);
2019 : 14524 : }
2020 : :
2021 : : /*
2022 : : * Match function for the hash table of RecordCacheEntry.
2023 : : */
2024 : : static int
2025 : 14700 : record_type_typmod_compare(const void *a, const void *b, size_t size)
2026 : : {
2027 : 14700 : const RecordCacheEntry *left = a;
2028 : 14700 : const RecordCacheEntry *right = b;
2029 : :
2030 : 29400 : return equalRowTypes(left->tupdesc, right->tupdesc) ? 0 : 1;
2031 : 14700 : }
2032 : :
2033 : : /*
2034 : : * assign_record_type_typmod
2035 : : *
2036 : : * Given a tuple descriptor for a RECORD type, find or create a cache entry
2037 : : * for the type, and set the tupdesc's tdtypmod field to a value that will
2038 : : * identify this cache entry to lookup_rowtype_tupdesc.
2039 : : */
2040 : : void
2041 : 14055 : assign_record_type_typmod(TupleDesc tupDesc)
2042 : : {
2043 : 14055 : RecordCacheEntry *recentry;
2044 : 14055 : TupleDesc entDesc;
2045 : 14055 : bool found;
2046 : 14055 : MemoryContext oldcxt;
2047 : :
2048 [ + - ]: 14055 : Assert(tupDesc->tdtypeid == RECORDOID);
2049 : :
2050 [ + + ]: 14055 : if (RecordCacheHash == NULL)
2051 : : {
2052 : : /* First time through: initialize the hash table */
2053 : 145 : HASHCTL ctl;
2054 : :
2055 : 145 : ctl.keysize = sizeof(TupleDesc); /* just the pointer */
2056 : 145 : ctl.entrysize = sizeof(RecordCacheEntry);
2057 : 145 : ctl.hash = record_type_typmod_hash;
2058 : 145 : ctl.match = record_type_typmod_compare;
2059 : 145 : RecordCacheHash = hash_create("Record information cache", 64,
2060 : : &ctl,
2061 : : HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);
2062 : :
2063 : : /* Also make sure CacheMemoryContext exists */
2064 [ + - ]: 145 : if (!CacheMemoryContext)
2065 : 0 : CreateCacheMemoryContext();
2066 : 145 : }
2067 : :
2068 : : /*
2069 : : * Find a hashtable entry for this tuple descriptor. We don't use
2070 : : * HASH_ENTER yet, because if it's missing, we need to make sure that all
2071 : : * the allocations succeed before we create the new entry.
2072 : : */
2073 : 14055 : recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
2074 : : &tupDesc,
2075 : : HASH_FIND, &found);
2076 [ + + - + ]: 14055 : if (found && recentry->tupdesc != NULL)
2077 : : {
2078 : 13586 : tupDesc->tdtypmod = recentry->tupdesc->tdtypmod;
2079 : 13586 : return;
2080 : : }
2081 : :
2082 : : /* Not present, so need to manufacture an entry */
2083 : 469 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
2084 : :
2085 : : /* Look in the SharedRecordTypmodRegistry, if attached */
2086 : 469 : entDesc = find_or_make_matching_shared_tupledesc(tupDesc);
2087 [ + + ]: 469 : if (entDesc == NULL)
2088 : : {
2089 : : /*
2090 : : * Make sure we have room before we CreateTupleDescCopy() or advance
2091 : : * NextRecordTypmod.
2092 : : */
2093 : 456 : ensure_record_cache_typmod_slot_exists(NextRecordTypmod);
2094 : :
2095 : : /* Reference-counted local cache only. */
2096 : 456 : entDesc = CreateTupleDescCopy(tupDesc);
2097 : 456 : entDesc->tdrefcount = 1;
2098 : 456 : entDesc->tdtypmod = NextRecordTypmod++;
2099 : 456 : }
2100 : : else
2101 : : {
2102 : 13 : ensure_record_cache_typmod_slot_exists(entDesc->tdtypmod);
2103 : : }
2104 : :
2105 : 469 : RecordCacheArray[entDesc->tdtypmod].tupdesc = entDesc;
2106 : :
2107 : : /* Assign a unique tupdesc identifier, too. */
2108 : 469 : RecordCacheArray[entDesc->tdtypmod].id = ++tupledesc_id_counter;
2109 : :
2110 : : /* Fully initialized; create the hash table entry */
2111 : 469 : recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
2112 : : &tupDesc,
2113 : : HASH_ENTER, NULL);
2114 : 469 : recentry->tupdesc = entDesc;
2115 : :
2116 : : /* Update the caller's tuple descriptor. */
2117 : 469 : tupDesc->tdtypmod = entDesc->tdtypmod;
2118 : :
2119 : 469 : MemoryContextSwitchTo(oldcxt);
2120 [ - + ]: 14055 : }
2121 : :
2122 : : /*
2123 : : * assign_record_type_identifier
2124 : : *
2125 : : * Get an identifier, which will be unique over the lifespan of this backend
2126 : : * process, for the current tuple descriptor of the specified composite type.
2127 : : * For named composite types, the value is guaranteed to change if the type's
2128 : : * definition does. For registered RECORD types, the value will not change
2129 : : * once assigned, since the registered type won't either. If an anonymous
2130 : : * RECORD type is specified, we return a new identifier on each call.
2131 : : */
2132 : : uint64
2133 : 809 : assign_record_type_identifier(Oid type_id, int32 typmod)
2134 : : {
2135 [ + - ]: 809 : if (type_id != RECORDOID)
2136 : : {
2137 : : /*
2138 : : * It's a named composite type, so use the regular typcache.
2139 : : */
2140 : 0 : TypeCacheEntry *typentry;
2141 : :
2142 : 0 : typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
2143 [ # # ]: 0 : if (typentry->tupDesc == NULL)
2144 [ # # # # ]: 0 : ereport(ERROR,
2145 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2146 : : errmsg("type %s is not composite",
2147 : : format_type_be(type_id))));
2148 [ # # ]: 0 : Assert(typentry->tupDesc_identifier != 0);
2149 : 0 : return typentry->tupDesc_identifier;
2150 : 0 : }
2151 : : else
2152 : : {
2153 : : /*
2154 : : * It's a transient record type, so look in our record-type table.
2155 : : */
2156 [ + + + - : 809 : if (typmod >= 0 && typmod < RecordCacheArrayLen &&
- + ]
2157 : 2 : RecordCacheArray[typmod].tupdesc != NULL)
2158 : : {
2159 [ + - ]: 2 : Assert(RecordCacheArray[typmod].id != 0);
2160 : 2 : return RecordCacheArray[typmod].id;
2161 : : }
2162 : :
2163 : : /* For anonymous or unrecognized record type, generate a new ID */
2164 : 807 : return ++tupledesc_id_counter;
2165 : : }
2166 : 809 : }
2167 : :
2168 : : /*
2169 : : * Return the amount of shmem required to hold a SharedRecordTypmodRegistry.
2170 : : * This exists only to avoid exposing private innards of
2171 : : * SharedRecordTypmodRegistry in a header.
2172 : : */
2173 : : size_t
2174 : 22 : SharedRecordTypmodRegistryEstimate(void)
2175 : : {
2176 : 22 : return sizeof(SharedRecordTypmodRegistry);
2177 : : }
2178 : :
2179 : : /*
2180 : : * Initialize 'registry' in a pre-existing shared memory region, which must be
2181 : : * maximally aligned and have space for SharedRecordTypmodRegistryEstimate()
2182 : : * bytes.
2183 : : *
2184 : : * 'area' will be used to allocate shared memory space as required for the
2185 : : * typemod registration. The current process, expected to be a leader process
2186 : : * in a parallel query, will be attached automatically and its current record
2187 : : * types will be loaded into *registry. While attached, all calls to
2188 : : * assign_record_type_typmod will use the shared registry. Worker backends
2189 : : * will need to attach explicitly.
2190 : : *
2191 : : * Note that this function takes 'area' and 'segment' as arguments rather than
2192 : : * accessing them via CurrentSession, because they aren't installed there
2193 : : * until after this function runs.
2194 : : */
2195 : : void
2196 : 22 : SharedRecordTypmodRegistryInit(SharedRecordTypmodRegistry *registry,
2197 : : dsm_segment *segment,
2198 : : dsa_area *area)
2199 : : {
2200 : 22 : MemoryContext old_context;
2201 : 22 : dshash_table *record_table;
2202 : 22 : dshash_table *typmod_table;
2203 : 22 : int32 typmod;
2204 : :
2205 [ + - ]: 22 : Assert(!IsParallelWorker());
2206 : :
2207 : : /* We can't already be attached to a shared registry. */
2208 [ + - ]: 22 : Assert(CurrentSession->shared_typmod_registry == NULL);
2209 [ + - ]: 22 : Assert(CurrentSession->shared_record_table == NULL);
2210 [ + - ]: 22 : Assert(CurrentSession->shared_typmod_table == NULL);
2211 : :
2212 : 22 : old_context = MemoryContextSwitchTo(TopMemoryContext);
2213 : :
2214 : : /* Create the hash table of tuple descriptors indexed by themselves. */
2215 : 22 : record_table = dshash_create(area, &srtr_record_table_params, area);
2216 : :
2217 : : /* Create the hash table of tuple descriptors indexed by typmod. */
2218 : 22 : typmod_table = dshash_create(area, &srtr_typmod_table_params, NULL);
2219 : :
2220 : 22 : MemoryContextSwitchTo(old_context);
2221 : :
2222 : : /* Initialize the SharedRecordTypmodRegistry. */
2223 : 22 : registry->record_table_handle = dshash_get_hash_table_handle(record_table);
2224 : 22 : registry->typmod_table_handle = dshash_get_hash_table_handle(typmod_table);
2225 : 22 : pg_atomic_init_u32(®istry->next_typmod, NextRecordTypmod);
2226 : :
2227 : : /*
2228 : : * Copy all entries from this backend's private registry into the shared
2229 : : * registry.
2230 : : */
2231 [ + + ]: 39 : for (typmod = 0; typmod < NextRecordTypmod; ++typmod)
2232 : : {
2233 : 17 : SharedTypmodTableEntry *typmod_table_entry;
2234 : 17 : SharedRecordTableEntry *record_table_entry;
2235 : 17 : SharedRecordTableKey record_table_key;
2236 : 17 : dsa_pointer shared_dp;
2237 : 17 : TupleDesc tupdesc;
2238 : 17 : bool found;
2239 : :
2240 : 17 : tupdesc = RecordCacheArray[typmod].tupdesc;
2241 [ + - ]: 17 : if (tupdesc == NULL)
2242 : 0 : continue;
2243 : :
2244 : : /* Copy the TupleDesc into shared memory. */
2245 : 17 : shared_dp = share_tupledesc(area, tupdesc, typmod);
2246 : :
2247 : : /* Insert into the typmod table. */
2248 : 34 : typmod_table_entry = dshash_find_or_insert(typmod_table,
2249 : 17 : &tupdesc->tdtypmod,
2250 : : &found);
2251 [ + - ]: 17 : if (found)
2252 [ # # # # ]: 0 : elog(ERROR, "cannot create duplicate shared record typmod");
2253 : 17 : typmod_table_entry->typmod = tupdesc->tdtypmod;
2254 : 17 : typmod_table_entry->shared_tupdesc = shared_dp;
2255 : 17 : dshash_release_lock(typmod_table, typmod_table_entry);
2256 : :
2257 : : /* Insert into the record table. */
2258 : 17 : record_table_key.shared = false;
2259 : 17 : record_table_key.u.local_tupdesc = tupdesc;
2260 : 17 : record_table_entry = dshash_find_or_insert(record_table,
2261 : : &record_table_key,
2262 : : &found);
2263 [ - + ]: 17 : if (!found)
2264 : : {
2265 : 17 : record_table_entry->key.shared = true;
2266 : 17 : record_table_entry->key.u.shared_tupdesc = shared_dp;
2267 : 17 : }
2268 : 17 : dshash_release_lock(record_table, record_table_entry);
2269 [ - - + ]: 17 : }
2270 : :
2271 : : /*
2272 : : * Set up the global state that will tell assign_record_type_typmod and
2273 : : * lookup_rowtype_tupdesc_internal about the shared registry.
2274 : : */
2275 : 22 : CurrentSession->shared_record_table = record_table;
2276 : 22 : CurrentSession->shared_typmod_table = typmod_table;
2277 : 22 : CurrentSession->shared_typmod_registry = registry;
2278 : :
2279 : : /*
2280 : : * We install a detach hook in the leader, but only to handle cleanup on
2281 : : * failure during GetSessionDsmHandle(). Once GetSessionDsmHandle() pins
2282 : : * the memory, the leader process will use a shared registry until it
2283 : : * exits.
2284 : : */
2285 : 22 : on_dsm_detach(segment, shared_record_typmod_registry_detach, (Datum) 0);
2286 : 22 : }
2287 : :
2288 : : /*
2289 : : * Attach to 'registry', which must have been initialized already by another
2290 : : * backend. Future calls to assign_record_type_typmod and
2291 : : * lookup_rowtype_tupdesc_internal will use the shared registry until the
2292 : : * current session is detached.
2293 : : */
2294 : : void
2295 : 477 : SharedRecordTypmodRegistryAttach(SharedRecordTypmodRegistry *registry)
2296 : : {
2297 : 477 : MemoryContext old_context;
2298 : 477 : dshash_table *record_table;
2299 : 477 : dshash_table *typmod_table;
2300 : :
2301 [ + - ]: 477 : Assert(IsParallelWorker());
2302 : :
2303 : : /* We can't already be attached to a shared registry. */
2304 [ + - ]: 477 : Assert(CurrentSession != NULL);
2305 [ + - ]: 477 : Assert(CurrentSession->segment != NULL);
2306 [ + - ]: 477 : Assert(CurrentSession->area != NULL);
2307 [ + - ]: 477 : Assert(CurrentSession->shared_typmod_registry == NULL);
2308 [ + - ]: 477 : Assert(CurrentSession->shared_record_table == NULL);
2309 [ + - ]: 477 : Assert(CurrentSession->shared_typmod_table == NULL);
2310 : :
2311 : : /*
2312 : : * We can't already have typmods in our local cache, because they'd clash
2313 : : * with those imported by SharedRecordTypmodRegistryInit. This should be
2314 : : * a freshly started parallel worker. If we ever support worker
2315 : : * recycling, a worker would need to zap its local cache in between
2316 : : * servicing different queries, in order to be able to call this and
2317 : : * synchronize typmods with a new leader; but that's problematic because
2318 : : * we can't be very sure that record-typmod-related state hasn't escaped
2319 : : * to anywhere else in the process.
2320 : : */
2321 [ + - ]: 477 : Assert(NextRecordTypmod == 0);
2322 : :
2323 : 477 : old_context = MemoryContextSwitchTo(TopMemoryContext);
2324 : :
2325 : : /* Attach to the two hash tables. */
2326 : 954 : record_table = dshash_attach(CurrentSession->area,
2327 : : &srtr_record_table_params,
2328 : 477 : registry->record_table_handle,
2329 : 477 : CurrentSession->area);
2330 : 954 : typmod_table = dshash_attach(CurrentSession->area,
2331 : : &srtr_typmod_table_params,
2332 : 477 : registry->typmod_table_handle,
2333 : : NULL);
2334 : :
2335 : 477 : MemoryContextSwitchTo(old_context);
2336 : :
2337 : : /*
2338 : : * Set up detach hook to run at worker exit. Currently this is the same
2339 : : * as the leader's detach hook, but in future they might need to be
2340 : : * different.
2341 : : */
2342 : 954 : on_dsm_detach(CurrentSession->segment,
2343 : : shared_record_typmod_registry_detach,
2344 : 477 : PointerGetDatum(registry));
2345 : :
2346 : : /*
2347 : : * Set up the session state that will tell assign_record_type_typmod and
2348 : : * lookup_rowtype_tupdesc_internal about the shared registry.
2349 : : */
2350 : 477 : CurrentSession->shared_typmod_registry = registry;
2351 : 477 : CurrentSession->shared_record_table = record_table;
2352 : 477 : CurrentSession->shared_typmod_table = typmod_table;
2353 : 477 : }
2354 : :
2355 : : /*
2356 : : * InvalidateCompositeTypeCacheEntry
2357 : : * Invalidate particular TypeCacheEntry on Relcache inval callback
2358 : : *
2359 : : * Delete the cached tuple descriptor (if any) for the given composite
2360 : : * type, and reset whatever info we have cached about the composite type's
2361 : : * comparability.
2362 : : */
2363 : : static void
2364 : 1460 : InvalidateCompositeTypeCacheEntry(TypeCacheEntry *typentry)
2365 : : {
2366 : 1460 : bool hadTupDescOrOpclass;
2367 : :
2368 [ + - ]: 1460 : Assert(typentry->typtype == TYPTYPE_COMPOSITE &&
2369 : : OidIsValid(typentry->typrelid));
2370 : :
2371 [ + + ]: 1460 : hadTupDescOrOpclass = (typentry->tupDesc != NULL) ||
2372 : 1031 : (typentry->flags & TCFLAGS_OPERATOR_FLAGS);
2373 : :
2374 : : /* Delete tupdesc if we have it */
2375 [ + + ]: 1460 : if (typentry->tupDesc != NULL)
2376 : : {
2377 : : /*
2378 : : * Release our refcount and free the tupdesc if none remain. We can't
2379 : : * use DecrTupleDescRefCount here because this reference is not logged
2380 : : * by the current resource owner.
2381 : : */
2382 [ + - ]: 429 : Assert(typentry->tupDesc->tdrefcount > 0);
2383 [ + + ]: 429 : if (--typentry->tupDesc->tdrefcount == 0)
2384 : 373 : FreeTupleDesc(typentry->tupDesc);
2385 : 429 : typentry->tupDesc = NULL;
2386 : :
2387 : : /*
2388 : : * Also clear tupDesc_identifier, so that anyone watching it will
2389 : : * realize that the tupdesc has changed.
2390 : : */
2391 : 429 : typentry->tupDesc_identifier = 0;
2392 : 429 : }
2393 : :
2394 : : /* Reset equality/comparison/hashing validity information */
2395 : 1460 : typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
2396 : :
2397 : : /*
2398 : : * Call delete_rel_type_cache_if_needed() if we actually cleared
2399 : : * something.
2400 : : */
2401 [ + + ]: 1460 : if (hadTupDescOrOpclass)
2402 : 429 : delete_rel_type_cache_if_needed(typentry);
2403 : 1460 : }
2404 : :
2405 : : /*
2406 : : * TypeCacheRelCallback
2407 : : * Relcache inval callback function
2408 : : *
2409 : : * Delete the cached tuple descriptor (if any) for the given rel's composite
2410 : : * type, or for all composite types if relid == InvalidOid. Also reset
2411 : : * whatever info we have cached about the composite type's comparability.
2412 : : *
2413 : : * This is called when a relcache invalidation event occurs for the given
2414 : : * relid. We can't use syscache to find a type corresponding to the given
2415 : : * relation because the code can be called outside of transaction. Thus, we
2416 : : * use the RelIdToTypeIdCacheHash map to locate appropriate typcache entry.
2417 : : */
2418 : : static void
2419 : 326757 : TypeCacheRelCallback(Datum arg, Oid relid)
2420 : : {
2421 : 326757 : TypeCacheEntry *typentry;
2422 : :
2423 : : /*
2424 : : * RelIdToTypeIdCacheHash and TypeCacheHash should exist, otherwise this
2425 : : * callback wouldn't be registered
2426 : : */
2427 [ + + ]: 326757 : if (OidIsValid(relid))
2428 : : {
2429 : 326672 : RelIdToTypeIdCacheEntry *relentry;
2430 : :
2431 : : /*
2432 : : * Find a RelIdToTypeIdCacheHash entry, which should exist as soon as
2433 : : * corresponding typcache entry has something to clean.
2434 : : */
2435 : 326672 : relentry = (RelIdToTypeIdCacheEntry *) hash_search(RelIdToTypeIdCacheHash,
2436 : : &relid,
2437 : : HASH_FIND, NULL);
2438 : :
2439 [ + + ]: 326672 : if (relentry != NULL)
2440 : : {
2441 : 2892 : typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
2442 : 1446 : &relentry->composite_typid,
2443 : : HASH_FIND, NULL);
2444 : :
2445 [ - + ]: 1446 : if (typentry != NULL)
2446 : : {
2447 [ + - ]: 1446 : Assert(typentry->typtype == TYPTYPE_COMPOSITE);
2448 [ + - ]: 1446 : Assert(relid == typentry->typrelid);
2449 : :
2450 : 1446 : InvalidateCompositeTypeCacheEntry(typentry);
2451 : 1446 : }
2452 : 1446 : }
2453 : :
2454 : : /*
2455 : : * Visit all the domain types sequentially. Typically, this shouldn't
2456 : : * affect performance since domain types are less tended to bloat.
2457 : : * Domain types are created manually, unlike composite types which are
2458 : : * automatically created for every temporary table.
2459 : : */
2460 [ + + ]: 535443 : for (typentry = firstDomainTypeEntry;
2461 : 535443 : typentry != NULL;
2462 : 208771 : typentry = typentry->nextDomain)
2463 : : {
2464 : : /*
2465 : : * If it's domain over composite, reset flags. (We don't bother
2466 : : * trying to determine whether the specific base type needs a
2467 : : * reset.) Note that if we haven't determined whether the base
2468 : : * type is composite, we don't need to reset anything.
2469 : : */
2470 [ + - ]: 208771 : if (typentry->flags & TCFLAGS_DOMAIN_BASE_IS_COMPOSITE)
2471 : 0 : typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
2472 : 208771 : }
2473 : 326672 : }
2474 : : else
2475 : : {
2476 : 85 : HASH_SEQ_STATUS status;
2477 : :
2478 : : /*
2479 : : * Relid is invalid. By convention, we need to reset all composite
2480 : : * types in cache. Also, we should reset flags for domain types, and
2481 : : * we loop over all entries in hash, so, do it in a single scan.
2482 : : */
2483 : 85 : hash_seq_init(&status, TypeCacheHash);
2484 [ + + ]: 528 : while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
2485 : : {
2486 [ + + ]: 443 : if (typentry->typtype == TYPTYPE_COMPOSITE)
2487 : : {
2488 : 14 : InvalidateCompositeTypeCacheEntry(typentry);
2489 : 14 : }
2490 [ + + ]: 429 : else if (typentry->typtype == TYPTYPE_DOMAIN)
2491 : : {
2492 : : /*
2493 : : * If it's domain over composite, reset flags. (We don't
2494 : : * bother trying to determine whether the specific base type
2495 : : * needs a reset.) Note that if we haven't determined whether
2496 : : * the base type is composite, we don't need to reset
2497 : : * anything.
2498 : : */
2499 [ + - ]: 9 : if (typentry->flags & TCFLAGS_DOMAIN_BASE_IS_COMPOSITE)
2500 : 0 : typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
2501 : 9 : }
2502 : : }
2503 : 85 : }
2504 : 326757 : }
2505 : :
2506 : : /*
2507 : : * TypeCacheTypCallback
2508 : : * Syscache inval callback function
2509 : : *
2510 : : * This is called when a syscache invalidation event occurs for any
2511 : : * pg_type row. If we have information cached about that type, mark
2512 : : * it as needing to be reloaded.
2513 : : */
2514 : : static void
2515 : 108470 : TypeCacheTypCallback(Datum arg, int cacheid, uint32 hashvalue)
2516 : : {
2517 : 108470 : HASH_SEQ_STATUS status;
2518 : 108470 : TypeCacheEntry *typentry;
2519 : :
2520 : : /* TypeCacheHash must exist, else this callback wouldn't be registered */
2521 : :
2522 : : /*
2523 : : * By convention, zero hash value is passed to the callback as a sign that
2524 : : * it's time to invalidate the whole cache. See sinval.c, inval.c and
2525 : : * InvalidateSystemCachesExtended().
2526 : : */
2527 [ + + ]: 108470 : if (hashvalue == 0)
2528 : 44 : hash_seq_init(&status, TypeCacheHash);
2529 : : else
2530 : 108426 : hash_seq_init_with_hash_value(&status, TypeCacheHash, hashvalue);
2531 : :
2532 [ + + ]: 109498 : while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
2533 : : {
2534 : 1028 : bool hadPgTypeData = (typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA);
2535 : :
2536 [ + + + - ]: 1028 : Assert(hashvalue == 0 || typentry->type_id_hash == hashvalue);
2537 : :
2538 : : /*
2539 : : * Mark the data obtained directly from pg_type as invalid. Also, if
2540 : : * it's a domain, typnotnull might've changed, so we'll need to
2541 : : * recalculate its constraints.
2542 : : */
2543 : 1028 : typentry->flags &= ~(TCFLAGS_HAVE_PG_TYPE_DATA |
2544 : : TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS);
2545 : :
2546 : : /*
2547 : : * Call delete_rel_type_cache_if_needed() if we cleaned
2548 : : * TCFLAGS_HAVE_PG_TYPE_DATA flag previously.
2549 : : */
2550 [ + + ]: 1028 : if (hadPgTypeData)
2551 : 598 : delete_rel_type_cache_if_needed(typentry);
2552 : 1028 : }
2553 : 108470 : }
2554 : :
2555 : : /*
2556 : : * TypeCacheOpcCallback
2557 : : * Syscache inval callback function
2558 : : *
2559 : : * This is called when a syscache invalidation event occurs for any pg_opclass
2560 : : * row. In principle we could probably just invalidate data dependent on the
2561 : : * particular opclass, but since updates on pg_opclass are rare in production
2562 : : * it doesn't seem worth a lot of complication: we just mark all cached data
2563 : : * invalid.
2564 : : *
2565 : : * Note that we don't bother watching for updates on pg_amop or pg_amproc.
2566 : : * This should be safe because ALTER OPERATOR FAMILY ADD/DROP OPERATOR/FUNCTION
2567 : : * is not allowed to be used to add/drop the primary operators and functions
2568 : : * of an opclass, only cross-type members of a family; and the latter sorts
2569 : : * of members are not going to get cached here.
2570 : : */
2571 : : static void
2572 : 283 : TypeCacheOpcCallback(Datum arg, int cacheid, uint32 hashvalue)
2573 : : {
2574 : 283 : HASH_SEQ_STATUS status;
2575 : 283 : TypeCacheEntry *typentry;
2576 : :
2577 : : /* TypeCacheHash must exist, else this callback wouldn't be registered */
2578 : 283 : hash_seq_init(&status, TypeCacheHash);
2579 [ + + ]: 2059 : while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
2580 : : {
2581 : 1776 : bool hadOpclass = (typentry->flags & TCFLAGS_OPERATOR_FLAGS);
2582 : :
2583 : : /* Reset equality/comparison/hashing validity information */
2584 : 1776 : typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
2585 : :
2586 : : /*
2587 : : * Call delete_rel_type_cache_if_needed() if we actually cleared some
2588 : : * of TCFLAGS_OPERATOR_FLAGS.
2589 : : */
2590 [ + + ]: 1776 : if (hadOpclass)
2591 : 339 : delete_rel_type_cache_if_needed(typentry);
2592 : 1776 : }
2593 : 283 : }
2594 : :
2595 : : /*
2596 : : * TypeCacheConstrCallback
2597 : : * Syscache inval callback function
2598 : : *
2599 : : * This is called when a syscache invalidation event occurs for any
2600 : : * pg_constraint row. We flush information about domain constraints
2601 : : * when this happens.
2602 : : *
2603 : : * It's slightly annoying that we can't tell whether the inval event was for
2604 : : * a domain constraint record or not; there's usually more update traffic
2605 : : * for table constraints than domain constraints, so we'll do a lot of
2606 : : * useless flushes. Still, this is better than the old no-caching-at-all
2607 : : * approach to domain constraints.
2608 : : */
2609 : : static void
2610 : 33056 : TypeCacheConstrCallback(Datum arg, int cacheid, uint32 hashvalue)
2611 : : {
2612 : 33056 : TypeCacheEntry *typentry;
2613 : :
2614 : : /*
2615 : : * Because this is called very frequently, and typically very few of the
2616 : : * typcache entries are for domains, we don't use hash_seq_search here.
2617 : : * Instead we thread all the domain-type entries together so that we can
2618 : : * visit them cheaply.
2619 : : */
2620 [ + + ]: 60232 : for (typentry = firstDomainTypeEntry;
2621 : 60232 : typentry != NULL;
2622 : 27176 : typentry = typentry->nextDomain)
2623 : : {
2624 : : /* Reset domain constraint validity information */
2625 : 27176 : typentry->flags &= ~TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS;
2626 : 27176 : }
2627 : 33056 : }
2628 : :
2629 : :
2630 : : /*
2631 : : * Check if given OID is part of the subset that's sortable by comparisons
2632 : : */
2633 : : static inline bool
2634 : 17 : enum_known_sorted(TypeCacheEnumData *enumdata, Oid arg)
2635 : : {
2636 : 17 : Oid offset;
2637 : :
2638 [ - + ]: 17 : if (arg < enumdata->bitmap_base)
2639 : 0 : return false;
2640 : 17 : offset = arg - enumdata->bitmap_base;
2641 [ - + ]: 17 : if (offset > (Oid) INT_MAX)
2642 : 0 : return false;
2643 : 17 : return bms_is_member((int) offset, enumdata->sorted_values);
2644 : 17 : }
2645 : :
2646 : :
2647 : : /*
2648 : : * compare_values_of_enum
2649 : : * Compare two members of an enum type.
2650 : : * Return <0, 0, or >0 according as arg1 <, =, or > arg2.
2651 : : *
2652 : : * Note: currently, the enumData cache is refreshed only if we are asked
2653 : : * to compare an enum value that is not already in the cache. This is okay
2654 : : * because there is no support for re-ordering existing values, so comparisons
2655 : : * of previously cached values will return the right answer even if other
2656 : : * values have been added since we last loaded the cache.
2657 : : *
2658 : : * Note: the enum logic has a special-case rule about even-numbered versus
2659 : : * odd-numbered OIDs, but we take no account of that rule here; this
2660 : : * routine shouldn't even get called when that rule applies.
2661 : : */
2662 : : int
2663 : 11 : compare_values_of_enum(TypeCacheEntry *tcache, Oid arg1, Oid arg2)
2664 : : {
2665 : 11 : TypeCacheEnumData *enumdata;
2666 : 11 : EnumItem *item1;
2667 : 11 : EnumItem *item2;
2668 : :
2669 : : /*
2670 : : * Equal OIDs are certainly equal --- this case was probably handled by
2671 : : * our caller, but we may as well check.
2672 : : */
2673 [ - + ]: 11 : if (arg1 == arg2)
2674 : 0 : return 0;
2675 : :
2676 : : /* Load up the cache if first time through */
2677 [ + + ]: 11 : if (tcache->enumData == NULL)
2678 : 1 : load_enum_cache_data(tcache);
2679 : 11 : enumdata = tcache->enumData;
2680 : :
2681 : : /*
2682 : : * If both OIDs are known-sorted, we can just compare them directly.
2683 : : */
2684 [ + + + - ]: 11 : if (enum_known_sorted(enumdata, arg1) &&
2685 : 6 : enum_known_sorted(enumdata, arg2))
2686 : : {
2687 [ # # ]: 0 : if (arg1 < arg2)
2688 : 0 : return -1;
2689 : : else
2690 : 0 : return 1;
2691 : : }
2692 : :
2693 : : /*
2694 : : * Slow path: we have to identify their actual sort-order positions.
2695 : : */
2696 : 11 : item1 = find_enumitem(enumdata, arg1);
2697 : 11 : item2 = find_enumitem(enumdata, arg2);
2698 : :
2699 [ + - + - ]: 11 : if (item1 == NULL || item2 == NULL)
2700 : : {
2701 : : /*
2702 : : * We couldn't find one or both values. That means the enum has
2703 : : * changed under us, so re-initialize the cache and try again. We
2704 : : * don't bother retrying the known-sorted case in this path.
2705 : : */
2706 : 0 : load_enum_cache_data(tcache);
2707 : 0 : enumdata = tcache->enumData;
2708 : :
2709 : 0 : item1 = find_enumitem(enumdata, arg1);
2710 : 0 : item2 = find_enumitem(enumdata, arg2);
2711 : :
2712 : : /*
2713 : : * If we still can't find the values, complain: we must have corrupt
2714 : : * data.
2715 : : */
2716 [ # # ]: 0 : if (item1 == NULL)
2717 [ # # # # ]: 0 : elog(ERROR, "enum value %u not found in cache for enum %s",
2718 : : arg1, format_type_be(tcache->type_id));
2719 [ # # ]: 0 : if (item2 == NULL)
2720 [ # # # # ]: 0 : elog(ERROR, "enum value %u not found in cache for enum %s",
2721 : : arg2, format_type_be(tcache->type_id));
2722 : 0 : }
2723 : :
2724 [ + + ]: 11 : if (item1->sort_order < item2->sort_order)
2725 : 4 : return -1;
2726 [ + - ]: 7 : else if (item1->sort_order > item2->sort_order)
2727 : 7 : return 1;
2728 : : else
2729 : 0 : return 0;
2730 : 11 : }
2731 : :
2732 : : /*
2733 : : * Load (or re-load) the enumData member of the typcache entry.
2734 : : */
2735 : : static void
2736 : 1 : load_enum_cache_data(TypeCacheEntry *tcache)
2737 : : {
2738 : 1 : TypeCacheEnumData *enumdata;
2739 : 1 : Relation enum_rel;
2740 : 1 : SysScanDesc enum_scan;
2741 : 1 : HeapTuple enum_tuple;
2742 : 1 : ScanKeyData skey;
2743 : 1 : EnumItem *items;
2744 : 1 : int numitems;
2745 : 1 : int maxitems;
2746 : 1 : Oid bitmap_base;
2747 : 1 : Bitmapset *bitmap;
2748 : 1 : MemoryContext oldcxt;
2749 : 1 : int bm_size,
2750 : : start_pos;
2751 : :
2752 : : /* Check that this is actually an enum */
2753 [ + - ]: 1 : if (tcache->typtype != TYPTYPE_ENUM)
2754 [ # # # # ]: 0 : ereport(ERROR,
2755 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2756 : : errmsg("%s is not an enum",
2757 : : format_type_be(tcache->type_id))));
2758 : :
2759 : : /*
2760 : : * Read all the information for members of the enum type. We collect the
2761 : : * info in working memory in the caller's context, and then transfer it to
2762 : : * permanent memory in CacheMemoryContext. This minimizes the risk of
2763 : : * leaking memory from CacheMemoryContext in the event of an error partway
2764 : : * through.
2765 : : */
2766 : 1 : maxitems = 64;
2767 : 1 : items = palloc_array(EnumItem, maxitems);
2768 : 1 : numitems = 0;
2769 : :
2770 : : /* Scan pg_enum for the members of the target enum type. */
2771 : 1 : ScanKeyInit(&skey,
2772 : : Anum_pg_enum_enumtypid,
2773 : : BTEqualStrategyNumber, F_OIDEQ,
2774 : 1 : ObjectIdGetDatum(tcache->type_id));
2775 : :
2776 : 1 : enum_rel = table_open(EnumRelationId, AccessShareLock);
2777 : 1 : enum_scan = systable_beginscan(enum_rel,
2778 : : EnumTypIdLabelIndexId,
2779 : : true, NULL,
2780 : : 1, &skey);
2781 : :
2782 [ + + ]: 9 : while (HeapTupleIsValid(enum_tuple = systable_getnext(enum_scan)))
2783 : : {
2784 : 8 : Form_pg_enum en = (Form_pg_enum) GETSTRUCT(enum_tuple);
2785 : :
2786 [ + - ]: 8 : if (numitems >= maxitems)
2787 : : {
2788 : 0 : maxitems *= 2;
2789 : 0 : items = (EnumItem *) repalloc(items, sizeof(EnumItem) * maxitems);
2790 : 0 : }
2791 : 8 : items[numitems].enum_oid = en->oid;
2792 : 8 : items[numitems].sort_order = en->enumsortorder;
2793 : 8 : numitems++;
2794 : 8 : }
2795 : :
2796 : 1 : systable_endscan(enum_scan);
2797 : 1 : table_close(enum_rel, AccessShareLock);
2798 : :
2799 : : /* Sort the items into OID order */
2800 : 1 : qsort(items, numitems, sizeof(EnumItem), enum_oid_cmp);
2801 : :
2802 : : /*
2803 : : * Here, we create a bitmap listing a subset of the enum's OIDs that are
2804 : : * known to be in order and can thus be compared with just OID comparison.
2805 : : *
2806 : : * The point of this is that the enum's initial OIDs were certainly in
2807 : : * order, so there is some subset that can be compared via OID comparison;
2808 : : * and we'd rather not do binary searches unnecessarily.
2809 : : *
2810 : : * This is somewhat heuristic, and might identify a subset of OIDs that
2811 : : * isn't exactly what the type started with. That's okay as long as the
2812 : : * subset is correctly sorted.
2813 : : */
2814 : 1 : bitmap_base = InvalidOid;
2815 : 1 : bitmap = NULL;
2816 : 1 : bm_size = 1; /* only save sets of at least 2 OIDs */
2817 : :
2818 [ - + ]: 3 : for (start_pos = 0; start_pos < numitems - 1; start_pos++)
2819 : : {
2820 : : /*
2821 : : * Identify longest sorted subsequence starting at start_pos
2822 : : */
2823 : 3 : Bitmapset *this_bitmap = bms_make_singleton(0);
2824 : 3 : int this_bm_size = 1;
2825 : 3 : Oid start_oid = items[start_pos].enum_oid;
2826 : 3 : float4 prev_order = items[start_pos].sort_order;
2827 : 3 : int i;
2828 : :
2829 [ + + ]: 21 : for (i = start_pos + 1; i < numitems; i++)
2830 : : {
2831 : 18 : Oid offset;
2832 : :
2833 : 18 : offset = items[i].enum_oid - start_oid;
2834 : : /* quit if bitmap would be too large; cutoff is arbitrary */
2835 [ - + ]: 18 : if (offset >= 8192)
2836 : 0 : break;
2837 : : /* include the item if it's in-order */
2838 [ + + ]: 18 : if (items[i].sort_order > prev_order)
2839 : : {
2840 : 9 : prev_order = items[i].sort_order;
2841 : 9 : this_bitmap = bms_add_member(this_bitmap, (int) offset);
2842 : 9 : this_bm_size++;
2843 : 9 : }
2844 [ - + ]: 18 : }
2845 : :
2846 : : /* Remember it if larger than previous best */
2847 [ + + ]: 3 : if (this_bm_size > bm_size)
2848 : : {
2849 : 1 : bms_free(bitmap);
2850 : 1 : bitmap_base = start_oid;
2851 : 1 : bitmap = this_bitmap;
2852 : 1 : bm_size = this_bm_size;
2853 : 1 : }
2854 : : else
2855 : 2 : bms_free(this_bitmap);
2856 : :
2857 : : /*
2858 : : * Done if it's not possible to find a longer sequence in the rest of
2859 : : * the list. In typical cases this will happen on the first
2860 : : * iteration, which is why we create the bitmaps on the fly instead of
2861 : : * doing a second pass over the list.
2862 : : */
2863 [ + + ]: 3 : if (bm_size >= (numitems - start_pos - 1))
2864 : 1 : break;
2865 [ + + ]: 3 : }
2866 : :
2867 : : /* OK, copy the data into CacheMemoryContext */
2868 : 1 : oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
2869 : 1 : enumdata = (TypeCacheEnumData *)
2870 : 1 : palloc(offsetof(TypeCacheEnumData, enum_values) +
2871 : 1 : numitems * sizeof(EnumItem));
2872 : 1 : enumdata->bitmap_base = bitmap_base;
2873 : 1 : enumdata->sorted_values = bms_copy(bitmap);
2874 : 1 : enumdata->num_values = numitems;
2875 : 1 : memcpy(enumdata->enum_values, items, numitems * sizeof(EnumItem));
2876 : 1 : MemoryContextSwitchTo(oldcxt);
2877 : :
2878 : 1 : pfree(items);
2879 : 1 : bms_free(bitmap);
2880 : :
2881 : : /* And link the finished cache struct into the typcache */
2882 [ - + ]: 1 : if (tcache->enumData != NULL)
2883 : 0 : pfree(tcache->enumData);
2884 : 1 : tcache->enumData = enumdata;
2885 : 1 : }
2886 : :
2887 : : /*
2888 : : * Locate the EnumItem with the given OID, if present
2889 : : */
2890 : : static EnumItem *
2891 : 22 : find_enumitem(TypeCacheEnumData *enumdata, Oid arg)
2892 : : {
2893 : 22 : EnumItem srch;
2894 : :
2895 : : /* On some versions of Solaris, bsearch of zero items dumps core */
2896 [ - + ]: 22 : if (enumdata->num_values <= 0)
2897 : 0 : return NULL;
2898 : :
2899 : 22 : srch.enum_oid = arg;
2900 : 22 : return bsearch(&srch, enumdata->enum_values, enumdata->num_values,
2901 : : sizeof(EnumItem), enum_oid_cmp);
2902 : 22 : }
2903 : :
2904 : : /*
2905 : : * qsort comparison function for OID-ordered EnumItems
2906 : : */
2907 : : static int
2908 : 79 : enum_oid_cmp(const void *left, const void *right)
2909 : : {
2910 : 79 : const EnumItem *l = (const EnumItem *) left;
2911 : 79 : const EnumItem *r = (const EnumItem *) right;
2912 : :
2913 : 158 : return pg_cmp_u32(l->enum_oid, r->enum_oid);
2914 : 79 : }
2915 : :
2916 : : /*
2917 : : * Copy 'tupdesc' into newly allocated shared memory in 'area', set its typmod
2918 : : * to the given value and return a dsa_pointer.
2919 : : */
2920 : : static dsa_pointer
2921 : 28 : share_tupledesc(dsa_area *area, TupleDesc tupdesc, uint32 typmod)
2922 : : {
2923 : 28 : dsa_pointer shared_dp;
2924 : 28 : TupleDesc shared;
2925 : :
2926 : 28 : shared_dp = dsa_allocate(area, TupleDescSize(tupdesc));
2927 : 28 : shared = (TupleDesc) dsa_get_address(area, shared_dp);
2928 : 28 : TupleDescCopy(shared, tupdesc);
2929 : 28 : shared->tdtypmod = typmod;
2930 : :
2931 : 56 : return shared_dp;
2932 : 28 : }
2933 : :
2934 : : /*
2935 : : * If we are attached to a SharedRecordTypmodRegistry, use it to find or
2936 : : * create a shared TupleDesc that matches 'tupdesc'. Otherwise return NULL.
2937 : : * Tuple descriptors returned by this function are not reference counted, and
2938 : : * will exist at least as long as the current backend remained attached to the
2939 : : * current session.
2940 : : */
2941 : : static TupleDesc
2942 : 469 : find_or_make_matching_shared_tupledesc(TupleDesc tupdesc)
2943 : : {
2944 : 469 : TupleDesc result;
2945 : 469 : SharedRecordTableKey key;
2946 : 469 : SharedRecordTableEntry *record_table_entry;
2947 : 469 : SharedTypmodTableEntry *typmod_table_entry;
2948 : 469 : dsa_pointer shared_dp;
2949 : 469 : bool found;
2950 : 469 : uint32 typmod;
2951 : :
2952 : : /* If not even attached, nothing to do. */
2953 [ + + ]: 469 : if (CurrentSession->shared_typmod_registry == NULL)
2954 : 456 : return NULL;
2955 : :
2956 : : /* Try to find a matching tuple descriptor in the record table. */
2957 : 13 : key.shared = false;
2958 : 13 : key.u.local_tupdesc = tupdesc;
2959 : 13 : record_table_entry = (SharedRecordTableEntry *)
2960 : 13 : dshash_find(CurrentSession->shared_record_table, &key, false);
2961 [ + + ]: 13 : if (record_table_entry)
2962 : : {
2963 [ + - ]: 2 : Assert(record_table_entry->key.shared);
2964 : 4 : dshash_release_lock(CurrentSession->shared_record_table,
2965 : 2 : record_table_entry);
2966 : 2 : result = (TupleDesc)
2967 : 4 : dsa_get_address(CurrentSession->area,
2968 : 2 : record_table_entry->key.u.shared_tupdesc);
2969 [ + - ]: 2 : Assert(result->tdrefcount == -1);
2970 : :
2971 : 2 : return result;
2972 : : }
2973 : :
2974 : : /* Allocate a new typmod number. This will be wasted if we error out. */
2975 : 11 : typmod = (int)
2976 : 11 : pg_atomic_fetch_add_u32(&CurrentSession->shared_typmod_registry->next_typmod,
2977 : : 1);
2978 : :
2979 : : /* Copy the TupleDesc into shared memory. */
2980 : 11 : shared_dp = share_tupledesc(CurrentSession->area, tupdesc, typmod);
2981 : :
2982 : : /*
2983 : : * Create an entry in the typmod table so that others will understand this
2984 : : * typmod number.
2985 : : */
2986 [ + - ]: 11 : PG_TRY();
2987 : : {
2988 : 11 : typmod_table_entry = (SharedTypmodTableEntry *)
2989 : 11 : dshash_find_or_insert(CurrentSession->shared_typmod_table,
2990 : : &typmod, &found);
2991 [ + - ]: 11 : if (found)
2992 [ # # # # ]: 0 : elog(ERROR, "cannot create duplicate shared record typmod");
2993 : : }
2994 : 11 : PG_CATCH();
2995 : : {
2996 : 0 : dsa_free(CurrentSession->area, shared_dp);
2997 : 0 : PG_RE_THROW();
2998 : : }
2999 [ + - ]: 11 : PG_END_TRY();
3000 : 11 : typmod_table_entry->typmod = typmod;
3001 : 11 : typmod_table_entry->shared_tupdesc = shared_dp;
3002 : 22 : dshash_release_lock(CurrentSession->shared_typmod_table,
3003 : 11 : typmod_table_entry);
3004 : :
3005 : : /*
3006 : : * Finally create an entry in the record table so others with matching
3007 : : * tuple descriptors can reuse the typmod.
3008 : : */
3009 : 11 : record_table_entry = (SharedRecordTableEntry *)
3010 : 11 : dshash_find_or_insert(CurrentSession->shared_record_table, &key,
3011 : : &found);
3012 [ - + ]: 11 : if (found)
3013 : : {
3014 : : /*
3015 : : * Someone concurrently inserted a matching tuple descriptor since the
3016 : : * first time we checked. Use that one instead.
3017 : : */
3018 : 0 : dshash_release_lock(CurrentSession->shared_record_table,
3019 : 0 : record_table_entry);
3020 : :
3021 : : /* Might as well free up the space used by the one we created. */
3022 : 0 : found = dshash_delete_key(CurrentSession->shared_typmod_table,
3023 : : &typmod);
3024 [ # # ]: 0 : Assert(found);
3025 : 0 : dsa_free(CurrentSession->area, shared_dp);
3026 : :
3027 : : /* Return the one we found. */
3028 [ # # ]: 0 : Assert(record_table_entry->key.shared);
3029 : 0 : result = (TupleDesc)
3030 : 0 : dsa_get_address(CurrentSession->area,
3031 : 0 : record_table_entry->key.u.shared_tupdesc);
3032 [ # # ]: 0 : Assert(result->tdrefcount == -1);
3033 : :
3034 : 0 : return result;
3035 : : }
3036 : :
3037 : : /* Store it and return it. */
3038 : 11 : record_table_entry->key.shared = true;
3039 : 11 : record_table_entry->key.u.shared_tupdesc = shared_dp;
3040 : 22 : dshash_release_lock(CurrentSession->shared_record_table,
3041 : 11 : record_table_entry);
3042 : 11 : result = (TupleDesc)
3043 : 11 : dsa_get_address(CurrentSession->area, shared_dp);
3044 [ + - ]: 11 : Assert(result->tdrefcount == -1);
3045 : :
3046 : 11 : return result;
3047 : 469 : }
3048 : :
3049 : : /*
3050 : : * On-DSM-detach hook to forget about the current shared record typmod
3051 : : * infrastructure. This is currently used by both leader and workers.
3052 : : */
3053 : : static void
3054 : 499 : shared_record_typmod_registry_detach(dsm_segment *segment, Datum datum)
3055 : : {
3056 : : /* Be cautious here: maybe we didn't finish initializing. */
3057 [ - + ]: 499 : if (CurrentSession->shared_record_table != NULL)
3058 : : {
3059 : 499 : dshash_detach(CurrentSession->shared_record_table);
3060 : 499 : CurrentSession->shared_record_table = NULL;
3061 : 499 : }
3062 [ - + ]: 499 : if (CurrentSession->shared_typmod_table != NULL)
3063 : : {
3064 : 499 : dshash_detach(CurrentSession->shared_typmod_table);
3065 : 499 : CurrentSession->shared_typmod_table = NULL;
3066 : 499 : }
3067 : 499 : CurrentSession->shared_typmod_registry = NULL;
3068 : 499 : }
3069 : :
3070 : : /*
3071 : : * Insert RelIdToTypeIdCacheHash entry if needed.
3072 : : */
3073 : : static void
3074 : 72684 : insert_rel_type_cache_if_needed(TypeCacheEntry *typentry)
3075 : : {
3076 : : /* Immediately quit for non-composite types */
3077 [ + + ]: 72684 : if (typentry->typtype != TYPTYPE_COMPOSITE)
3078 : 63750 : return;
3079 : :
3080 : : /* typrelid should be given for composite types */
3081 [ + - ]: 8934 : Assert(OidIsValid(typentry->typrelid));
3082 : :
3083 : : /*
3084 : : * Insert a RelIdToTypeIdCacheHash entry if the typentry have any
3085 : : * information indicating it should be here.
3086 : : */
3087 [ - + ]: 8934 : if ((typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA) ||
3088 [ # # # # ]: 0 : (typentry->flags & TCFLAGS_OPERATOR_FLAGS) ||
3089 : 0 : typentry->tupDesc != NULL)
3090 : : {
3091 : 8934 : RelIdToTypeIdCacheEntry *relentry;
3092 : 8934 : bool found;
3093 : :
3094 : 17868 : relentry = (RelIdToTypeIdCacheEntry *) hash_search(RelIdToTypeIdCacheHash,
3095 : 8934 : &typentry->typrelid,
3096 : : HASH_ENTER, &found);
3097 : 8934 : relentry->relid = typentry->typrelid;
3098 : 8934 : relentry->composite_typid = typentry->type_id;
3099 : 8934 : }
3100 : 72684 : }
3101 : :
3102 : : /*
3103 : : * Delete entry RelIdToTypeIdCacheHash if needed after resetting of the
3104 : : * TCFLAGS_HAVE_PG_TYPE_DATA flag, or any of TCFLAGS_OPERATOR_FLAGS,
3105 : : * or tupDesc.
3106 : : */
3107 : : static void
3108 : 1366 : delete_rel_type_cache_if_needed(TypeCacheEntry *typentry)
3109 : : {
3110 : : #ifdef USE_ASSERT_CHECKING
3111 : 1366 : int i;
3112 : 1366 : bool is_in_progress = false;
3113 : :
3114 [ + + ]: 1366 : for (i = 0; i < in_progress_list_len; i++)
3115 : : {
3116 [ + - ]: 3 : if (in_progress_list[i] == typentry->type_id)
3117 : : {
3118 : 3 : is_in_progress = true;
3119 : 3 : break;
3120 : : }
3121 : 0 : }
3122 : : #endif
3123 : :
3124 : : /* Immediately quit for non-composite types */
3125 [ + + ]: 1366 : if (typentry->typtype != TYPTYPE_COMPOSITE)
3126 : 640 : return;
3127 : :
3128 : : /* typrelid should be given for composite types */
3129 [ + - ]: 726 : Assert(OidIsValid(typentry->typrelid));
3130 : :
3131 : : /*
3132 : : * Delete a RelIdToTypeIdCacheHash entry if the typentry doesn't have any
3133 : : * information indicating entry should be still there.
3134 : : */
3135 [ + + ]: 726 : if (!(typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA) &&
3136 [ + + + + ]: 353 : !(typentry->flags & TCFLAGS_OPERATOR_FLAGS) &&
3137 : 342 : typentry->tupDesc == NULL)
3138 : : {
3139 : 296 : bool found;
3140 : :
3141 : 592 : (void) hash_search(RelIdToTypeIdCacheHash,
3142 : 296 : &typentry->typrelid,
3143 : : HASH_REMOVE, &found);
3144 [ - + # # ]: 296 : Assert(found || is_in_progress);
3145 : 296 : }
3146 : : else
3147 : : {
3148 : : #ifdef USE_ASSERT_CHECKING
3149 : : /*
3150 : : * In assert-enabled builds otherwise check for RelIdToTypeIdCacheHash
3151 : : * entry if it should exist.
3152 : : */
3153 : 430 : bool found;
3154 : :
3155 [ - + ]: 430 : if (!is_in_progress)
3156 : : {
3157 : 860 : (void) hash_search(RelIdToTypeIdCacheHash,
3158 : 430 : &typentry->typrelid,
3159 : : HASH_FIND, &found);
3160 [ + - ]: 430 : Assert(found);
3161 : 430 : }
3162 : : #endif
3163 : 430 : }
3164 [ - + ]: 1366 : }
3165 : :
3166 : : /*
3167 : : * Add possibly missing RelIdToTypeId entries related to TypeCacheHash
3168 : : * entries, marked as in-progress by lookup_type_cache(). It may happen
3169 : : * in case of an error or interruption during the lookup_type_cache() call.
3170 : : */
3171 : : static void
3172 : 59579 : finalize_in_progress_typentries(void)
3173 : : {
3174 : 59579 : int i;
3175 : :
3176 [ - + ]: 59579 : for (i = 0; i < in_progress_list_len; i++)
3177 : : {
3178 : 0 : TypeCacheEntry *typentry;
3179 : :
3180 : 0 : typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
3181 : 0 : &in_progress_list[i],
3182 : : HASH_FIND, NULL);
3183 [ # # ]: 0 : if (typentry)
3184 : 0 : insert_rel_type_cache_if_needed(typentry);
3185 : 0 : }
3186 : :
3187 : 59579 : in_progress_list_len = 0;
3188 : 59579 : }
3189 : :
3190 : : void
3191 : 57914 : AtEOXact_TypeCache(void)
3192 : : {
3193 : 57914 : finalize_in_progress_typentries();
3194 : 57914 : }
3195 : :
3196 : : void
3197 : 1665 : AtEOSubXact_TypeCache(void)
3198 : : {
3199 : 1665 : finalize_in_progress_typentries();
3200 : 1665 : }
|
