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