#include "access/tupdesc.h"
#include "fmgr.h"
#include "storage/dsm.h"
#include "utils/dsa.h"

Include dependency graph for typcache.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	TypeCacheEntry

struct	DomainConstraintRef

Macros
#define	TYPECACHE_EQ_OPR 0x00001

#define	TYPECACHE_LT_OPR 0x00002

#define	TYPECACHE_GT_OPR 0x00004

#define	TYPECACHE_CMP_PROC 0x00008

#define	TYPECACHE_HASH_PROC 0x00010

#define	TYPECACHE_EQ_OPR_FINFO 0x00020

#define	TYPECACHE_CMP_PROC_FINFO 0x00040

#define	TYPECACHE_HASH_PROC_FINFO 0x00080

#define	TYPECACHE_TUPDESC 0x00100

#define	TYPECACHE_BTREE_OPFAMILY 0x00200

#define	TYPECACHE_HASH_OPFAMILY 0x00400

#define	TYPECACHE_RANGE_INFO 0x00800

#define	TYPECACHE_DOMAIN_BASE_INFO 0x01000

#define	TYPECACHE_DOMAIN_CONSTR_INFO 0x02000

#define	TYPECACHE_HASH_EXTENDED_PROC 0x04000

#define	TYPECACHE_HASH_EXTENDED_PROC_FINFO 0x08000

#define	TYPECACHE_MULTIRANGE_INFO 0x10000

#define	INVALID_TUPLEDESC_IDENTIFIER ((uint64) 1)

Typedefs
typedef struct DomainConstraintCache	DomainConstraintCache

typedef struct TypeCacheEntry	TypeCacheEntry

typedef struct DomainConstraintRef	DomainConstraintRef

typedef struct SharedRecordTypmodRegistry	SharedRecordTypmodRegistry

Functions
TypeCacheEntry *	lookup_type_cache (Oid type_id, int flags)

void	InitDomainConstraintRef (Oid type_id, DomainConstraintRef *ref, MemoryContext refctx, bool need_exprstate)

void	UpdateDomainConstraintRef (DomainConstraintRef *ref)

bool	DomainHasConstraints (Oid type_id)

TupleDesc	lookup_rowtype_tupdesc (Oid type_id, int32 typmod)

TupleDesc	lookup_rowtype_tupdesc_noerror (Oid type_id, int32 typmod, bool noError)

TupleDesc	lookup_rowtype_tupdesc_copy (Oid type_id, int32 typmod)

TupleDesc	lookup_rowtype_tupdesc_domain (Oid type_id, int32 typmod, bool noError)

void	assign_record_type_typmod (TupleDesc tupDesc)

uint64	assign_record_type_identifier (Oid type_id, int32 typmod)

int	compare_values_of_enum (TypeCacheEntry *tcache, Oid arg1, Oid arg2)

size_t	SharedRecordTypmodRegistryEstimate (void)

void	SharedRecordTypmodRegistryInit (SharedRecordTypmodRegistry , dsm_segment segment, dsa_area *area)

void	SharedRecordTypmodRegistryAttach (SharedRecordTypmodRegistry *)

void	AtEOXact_TypeCache (void)

void	AtEOSubXact_TypeCache (void)

Macro Definition Documentation

◆ INVALID_TUPLEDESC_IDENTIFIER

#define INVALID_TUPLEDESC_IDENTIFIER ((uint64) 1)

Definition at line 156 of file typcache.h.

◆ TYPECACHE_BTREE_OPFAMILY

#define TYPECACHE_BTREE_OPFAMILY 0x00200

Definition at line 146 of file typcache.h.

◆ TYPECACHE_CMP_PROC

#define TYPECACHE_CMP_PROC 0x00008

Definition at line 140 of file typcache.h.

◆ TYPECACHE_CMP_PROC_FINFO

#define TYPECACHE_CMP_PROC_FINFO 0x00040

Definition at line 143 of file typcache.h.

◆ TYPECACHE_DOMAIN_BASE_INFO

#define TYPECACHE_DOMAIN_BASE_INFO 0x01000

Definition at line 149 of file typcache.h.

◆ TYPECACHE_DOMAIN_CONSTR_INFO

#define TYPECACHE_DOMAIN_CONSTR_INFO 0x02000

Definition at line 150 of file typcache.h.

◆ TYPECACHE_EQ_OPR

#define TYPECACHE_EQ_OPR 0x00001

Definition at line 137 of file typcache.h.

◆ TYPECACHE_EQ_OPR_FINFO

#define TYPECACHE_EQ_OPR_FINFO 0x00020

Definition at line 142 of file typcache.h.

◆ TYPECACHE_GT_OPR

#define TYPECACHE_GT_OPR 0x00004

Definition at line 139 of file typcache.h.

◆ TYPECACHE_HASH_EXTENDED_PROC

#define TYPECACHE_HASH_EXTENDED_PROC 0x04000

Definition at line 151 of file typcache.h.

◆ TYPECACHE_HASH_EXTENDED_PROC_FINFO

#define TYPECACHE_HASH_EXTENDED_PROC_FINFO 0x08000

Definition at line 152 of file typcache.h.

◆ TYPECACHE_HASH_OPFAMILY

#define TYPECACHE_HASH_OPFAMILY 0x00400

Definition at line 147 of file typcache.h.

◆ TYPECACHE_HASH_PROC

#define TYPECACHE_HASH_PROC 0x00010

Definition at line 141 of file typcache.h.

◆ TYPECACHE_HASH_PROC_FINFO

#define TYPECACHE_HASH_PROC_FINFO 0x00080

Definition at line 144 of file typcache.h.

◆ TYPECACHE_LT_OPR

#define TYPECACHE_LT_OPR 0x00002

Definition at line 138 of file typcache.h.

◆ TYPECACHE_MULTIRANGE_INFO

#define TYPECACHE_MULTIRANGE_INFO 0x10000

Definition at line 153 of file typcache.h.

◆ TYPECACHE_RANGE_INFO

#define TYPECACHE_RANGE_INFO 0x00800

Definition at line 148 of file typcache.h.

◆ TYPECACHE_TUPDESC

#define TYPECACHE_TUPDESC 0x00100

Definition at line 145 of file typcache.h.

Typedef Documentation

◆ DomainConstraintCache

typedef struct DomainConstraintCache DomainConstraintCache

Definition at line 1 of file typcache.h.

◆ DomainConstraintRef

typedef struct DomainConstraintRef DomainConstraintRef

◆ SharedRecordTypmodRegistry

typedef struct SharedRecordTypmodRegistry SharedRecordTypmodRegistry

Definition at line 1 of file typcache.h.

◆ TypeCacheEntry

typedef struct TypeCacheEntry TypeCacheEntry

Function Documentation

◆ assign_record_type_identifier()

uint64 assign_record_type_identifier	(	Oid	type_id,
		int32	typmod
	)

Definition at line 2132 of file typcache.c.

 {
     if (type_id != RECORDOID)
     {
         /*
          * It's a named composite type, so use the regular typcache.
          */
         TypeCacheEntry *typentry;
  
         typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
         if (typentry->tupDesc == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("type %s is not composite",
                             format_type_be(type_id))));
         Assert(typentry->tupDesc_identifier != 0);
         return typentry->tupDesc_identifier;
     }
     else
     {
         /*
          * It's a transient record type, so look in our record-type table.
          */
         if (typmod >= 0 && typmod < RecordCacheArrayLen &&
             RecordCacheArray[typmod].tupdesc != NULL)
         {
             Assert(RecordCacheArray[typmod].id != 0);
             return RecordCacheArray[typmod].id;
         }
  
         /* For anonymous or unrecognized record type, generate a new ID */
         return ++tupledesc_id_counter;
     }
 }

References Assert, ereport, errcode(), errmsg(), ERROR, format_type_be(), RecordCacheArrayEntry::id, lookup_type_cache(), RecordCacheArray, RecordCacheArrayLen, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, tupledesc_id_counter, and TYPECACHE_TUPDESC.

Referenced by expanded_record_fetch_tupdesc(), make_expanded_record_from_tupdesc(), and make_expanded_record_from_typeid().

◆ assign_record_type_typmod()

void assign_record_type_typmod ( TupleDesc tupDesc )

Definition at line 2040 of file typcache.c.

 {
     RecordCacheEntry *recentry;
     TupleDesc   entDesc;
     bool        found;
     MemoryContext oldcxt;
  
     Assert(tupDesc->tdtypeid == RECORDOID);
  
     if (RecordCacheHash == NULL)
     {
         /* First time through: initialize the hash table */
         HASHCTL     ctl;
  
         ctl.keysize = sizeof(TupleDesc);    /* just the pointer */
         ctl.entrysize = sizeof(RecordCacheEntry);
         ctl.hash = record_type_typmod_hash;
         ctl.match = record_type_typmod_compare;
         RecordCacheHash = hash_create("Record information cache", 64,
                                       &ctl,
                                       HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);
  
         /* Also make sure CacheMemoryContext exists */
         if (!CacheMemoryContext)
             CreateCacheMemoryContext();
     }
  
     /*
      * Find a hashtable entry for this tuple descriptor. We don't use
      * HASH_ENTER yet, because if it's missing, we need to make sure that all
      * the allocations succeed before we create the new entry.
      */
     recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
                                                 &tupDesc,
                                                 HASH_FIND, &found);
     if (found && recentry->tupdesc != NULL)
     {
         tupDesc->tdtypmod = recentry->tupdesc->tdtypmod;
         return;
     }
  
     /* Not present, so need to manufacture an entry */
     oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
  
     /* Look in the SharedRecordTypmodRegistry, if attached */
     entDesc = find_or_make_matching_shared_tupledesc(tupDesc);
     if (entDesc == NULL)
     {
         /*
          * Make sure we have room before we CreateTupleDescCopy() or advance
          * NextRecordTypmod.
          */
         ensure_record_cache_typmod_slot_exists(NextRecordTypmod);
  
         /* Reference-counted local cache only. */
         entDesc = CreateTupleDescCopy(tupDesc);
         entDesc->tdrefcount = 1;
         entDesc->tdtypmod = NextRecordTypmod++;
     }
     else
     {
         ensure_record_cache_typmod_slot_exists(entDesc->tdtypmod);
     }
  
     RecordCacheArray[entDesc->tdtypmod].tupdesc = entDesc;
  
     /* Assign a unique tupdesc identifier, too. */
     RecordCacheArray[entDesc->tdtypmod].id = ++tupledesc_id_counter;
  
     /* Fully initialized; create the hash table entry */
     recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
                                                 &tupDesc,
                                                 HASH_ENTER, NULL);
     recentry->tupdesc = entDesc;
  
     /* Update the caller's tuple descriptor. */
     tupDesc->tdtypmod = entDesc->tdtypmod;
  
     MemoryContextSwitchTo(oldcxt);
 }

References Assert, CacheMemoryContext, CreateCacheMemoryContext(), CreateTupleDescCopy(), ctl, ensure_record_cache_typmod_slot_exists(), find_or_make_matching_shared_tupledesc(), HASH_COMPARE, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FIND, HASH_FUNCTION, hash_search(), RecordCacheArrayEntry::id, MemoryContextSwitchTo(), NextRecordTypmod, record_type_typmod_compare(), record_type_typmod_hash(), RecordCacheArray, RecordCacheHash, TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, RecordCacheEntry::tupdesc, RecordCacheArrayEntry::tupdesc, and tupledesc_id_counter.

Referenced by BlessTupleDesc(), ER_get_flat_size(), internal_get_result_type(), and SPI_returntuple().

◆ AtEOSubXact_TypeCache()

void AtEOSubXact_TypeCache ( void )

Definition at line 3184 of file typcache.c.

 {
     finalize_in_progress_typentries();
 }

References finalize_in_progress_typentries().

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_TypeCache()

void AtEOXact_TypeCache ( void )

Definition at line 3178 of file typcache.c.

 {
     finalize_in_progress_typentries();
 }

References finalize_in_progress_typentries().

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

◆ compare_values_of_enum()

int compare_values_of_enum	(	TypeCacheEntry *	tcache,
		Oid	arg1,
		Oid	arg2
	)

Definition at line 2650 of file typcache.c.

 {
     TypeCacheEnumData *enumdata;
     EnumItem   *item1;
     EnumItem   *item2;
  
     /*
      * Equal OIDs are certainly equal --- this case was probably handled by
      * our caller, but we may as well check.
      */
     if (arg1 == arg2)
         return 0;
  
     /* Load up the cache if first time through */
     if (tcache->enumData == NULL)
         load_enum_cache_data(tcache);
     enumdata = tcache->enumData;
  
     /*
      * If both OIDs are known-sorted, we can just compare them directly.
      */
     if (enum_known_sorted(enumdata, arg1) &&
         enum_known_sorted(enumdata, arg2))
     {
         if (arg1 < arg2)
             return -1;
         else
             return 1;
     }
  
     /*
      * Slow path: we have to identify their actual sort-order positions.
      */
     item1 = find_enumitem(enumdata, arg1);
     item2 = find_enumitem(enumdata, arg2);
  
     if (item1 == NULL || item2 == NULL)
     {
         /*
          * We couldn't find one or both values.  That means the enum has
          * changed under us, so re-initialize the cache and try again. We
          * don't bother retrying the known-sorted case in this path.
          */
         load_enum_cache_data(tcache);
         enumdata = tcache->enumData;
  
         item1 = find_enumitem(enumdata, arg1);
         item2 = find_enumitem(enumdata, arg2);
  
         /*
          * If we still can't find the values, complain: we must have corrupt
          * data.
          */
         if (item1 == NULL)
             elog(ERROR, "enum value %u not found in cache for enum %s",
                  arg1, format_type_be(tcache->type_id));
         if (item2 == NULL)
             elog(ERROR, "enum value %u not found in cache for enum %s",
                  arg2, format_type_be(tcache->type_id));
     }
  
     if (item1->sort_order < item2->sort_order)
         return -1;
     else if (item1->sort_order > item2->sort_order)
         return 1;
     else
         return 0;
 }

References elog, enum_known_sorted(), TypeCacheEntry::enumData, ERROR, find_enumitem(), format_type_be(), load_enum_cache_data(), EnumItem::sort_order, and TypeCacheEntry::type_id.

Referenced by enum_cmp_internal().

◆ DomainHasConstraints()

bool DomainHasConstraints ( Oid type_id )

Definition at line 1487 of file typcache.c.

 {
     TypeCacheEntry *typentry;
  
     /*
      * Note: a side effect is to cause the typcache's domain data to become
      * valid.  This is fine since we'll likely need it soon if there is any.
      */
     typentry = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
  
     return (typentry->domainData != NULL);
 }

References TypeCacheEntry::domainData, lookup_type_cache(), and TYPECACHE_DOMAIN_CONSTR_INFO.

Referenced by ATColumnChangeRequiresRewrite(), ATExecAddColumn(), eval_const_expressions_mutator(), ExecInitJsonCoercion(), and transformJsonFuncExpr().

◆ InitDomainConstraintRef()

void InitDomainConstraintRef	(	Oid	type_id,
		DomainConstraintRef *	ref,
		MemoryContext	refctx,
		bool	need_exprstate
	)

Definition at line 1400 of file typcache.c.

 {
     /* Look up the typcache entry --- we assume it survives indefinitely */
     ref->tcache = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
     ref->need_exprstate = need_exprstate;
     /* For safety, establish the callback before acquiring a refcount */
     ref->refctx = refctx;
     ref->dcc = NULL;
     ref->callback.func = dccref_deletion_callback;
     ref->callback.arg = ref;
     MemoryContextRegisterResetCallback(refctx, &ref->callback);
     /* Acquire refcount if there are constraints, and set up exported list */
     if (ref->tcache->domainData)
     {
         ref->dcc = ref->tcache->domainData;
         ref->dcc->dccRefCount++;
         if (ref->need_exprstate)
             ref->constraints = prep_domain_constraints(ref->dcc->constraints,
                                                        ref->refctx);
         else
             ref->constraints = ref->dcc->constraints;
     }
     else
         ref->constraints = NIL;
 }

References MemoryContextCallback::arg, DomainConstraintRef::callback, DomainConstraintCache::constraints, DomainConstraintRef::constraints, DomainConstraintRef::dcc, dccref_deletion_callback(), DomainConstraintCache::dccRefCount, TypeCacheEntry::domainData, MemoryContextCallback::func, lookup_type_cache(), MemoryContextRegisterResetCallback(), DomainConstraintRef::need_exprstate, NIL, prep_domain_constraints(), DomainConstraintRef::refctx, DomainConstraintRef::tcache, and TYPECACHE_DOMAIN_CONSTR_INFO.

Referenced by domain_state_setup(), and ExecInitCoerceToDomain().

◆ lookup_rowtype_tupdesc()

TupleDesc lookup_rowtype_tupdesc	(	Oid	type_id,
		int32	typmod
	)

Definition at line 1920 of file typcache.c.

 {
     TupleDesc   tupDesc;
  
     tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
     PinTupleDesc(tupDesc);
     return tupDesc;
 }

References lookup_rowtype_tupdesc_internal(), and PinTupleDesc.

Referenced by ATExecAddOf(), coerce_record_to_complex(), composite_to_json(), composite_to_jsonb(), deconstruct_composite_datum(), exec_move_row_from_datum(), ExecInitExprRec(), ExecuteCallStmt(), expanded_record_fetch_tupdesc(), get_cached_rowtype(), get_rule_expr(), GetAttributeByName(), GetAttributeByNum(), hash_record(), hash_record_extended(), HeapTupleHeaderGetDatum(), make_expanded_record_from_typeid(), make_tuple_indirect(), plperl_hash_from_datum(), pltcl_func_handler(), PLyDict_FromComposite(), PLyObject_ToComposite(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_out(), record_recv(), record_send(), transformOfType(), and update_cached_tupdesc().

◆ lookup_rowtype_tupdesc_copy()

TupleDesc lookup_rowtype_tupdesc_copy	(	Oid	type_id,
		int32	typmod
	)

Definition at line 1954 of file typcache.c.

 {
     TupleDesc   tmp;
  
     tmp = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
     return CreateTupleDescCopyConstr(tmp);
 }

References CreateTupleDescCopyConstr(), and lookup_rowtype_tupdesc_internal().

Referenced by ExecInitExprRec(), ExecMakeTableFunctionResult(), get_expr_result_type(), internal_get_result_type(), and TypeGetTupleDesc().

◆ lookup_rowtype_tupdesc_domain()

TupleDesc lookup_rowtype_tupdesc_domain	(	Oid	type_id,
		int32	typmod,
		bool	noError
	)

Definition at line 1976 of file typcache.c.

 {
     TupleDesc   tupDesc;
  
     if (type_id != RECORDOID)
     {
         /*
          * Check for domain or named composite type.  We might as well load
          * whichever data is needed.
          */
         TypeCacheEntry *typentry;
  
         typentry = lookup_type_cache(type_id,
                                      TYPECACHE_TUPDESC |
                                      TYPECACHE_DOMAIN_BASE_INFO);
         if (typentry->typtype == TYPTYPE_DOMAIN)
             return lookup_rowtype_tupdesc_noerror(typentry->domainBaseType,
                                                   typentry->domainBaseTypmod,
                                                   noError);
         if (typentry->tupDesc == NULL && !noError)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("type %s is not composite",
                             format_type_be(type_id))));
         tupDesc = typentry->tupDesc;
     }
     else
         tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
     if (tupDesc != NULL)
         PinTupleDesc(tupDesc);
     return tupDesc;
 }

References TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, ereport, errcode(), errmsg(), ERROR, format_type_be(), lookup_rowtype_tupdesc_internal(), lookup_rowtype_tupdesc_noerror(), lookup_type_cache(), PinTupleDesc, TypeCacheEntry::tupDesc, TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_TUPDESC, and TypeCacheEntry::typtype.

Referenced by ExecEvalWholeRowVar(), hstore_from_record(), hstore_populate_record(), plperl_sv_to_datum(), and rowtype_field_matches().

◆ lookup_rowtype_tupdesc_noerror()

TupleDesc lookup_rowtype_tupdesc_noerror	(	Oid	type_id,
		int32	typmod,
		bool	noError
	)

Definition at line 1937 of file typcache.c.

 {
     TupleDesc   tupDesc;
  
     tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
     if (tupDesc != NULL)
         PinTupleDesc(tupDesc);
     return tupDesc;
 }

References lookup_rowtype_tupdesc_internal(), and PinTupleDesc.

Referenced by lookup_rowtype_tupdesc_domain().

◆ lookup_type_cache()

TypeCacheEntry* lookup_type_cache	(	Oid	type_id,
		int	flags
	)

Definition at line 386 of file typcache.c.

 {
     TypeCacheEntry *typentry;
     bool        found;
     int         in_progress_offset;
  
     if (TypeCacheHash == NULL)
     {
         /* First time through: initialize the hash table */
         HASHCTL     ctl;
         int         allocsize;
  
         ctl.keysize = sizeof(Oid);
         ctl.entrysize = sizeof(TypeCacheEntry);
  
         /*
          * TypeCacheEntry takes hash value from the system cache. For
          * TypeCacheHash we use the same hash in order to speedup search by
          * hash value. This is used by hash_seq_init_with_hash_value().
          */
         ctl.hash = type_cache_syshash;
  
         TypeCacheHash = hash_create("Type information cache", 64,
                                     &ctl, HASH_ELEM | HASH_FUNCTION);
  
         Assert(RelIdToTypeIdCacheHash == NULL);
  
         ctl.keysize = sizeof(Oid);
         ctl.entrysize = sizeof(RelIdToTypeIdCacheEntry);
         RelIdToTypeIdCacheHash = hash_create("Map from relid to OID of cached composite type", 64,
                                              &ctl, HASH_ELEM | HASH_BLOBS);
  
         /* Also set up callbacks for SI invalidations */
         CacheRegisterRelcacheCallback(TypeCacheRelCallback, (Datum) 0);
         CacheRegisterSyscacheCallback(TYPEOID, TypeCacheTypCallback, (Datum) 0);
         CacheRegisterSyscacheCallback(CLAOID, TypeCacheOpcCallback, (Datum) 0);
         CacheRegisterSyscacheCallback(CONSTROID, TypeCacheConstrCallback, (Datum) 0);
  
         /* Also make sure CacheMemoryContext exists */
         if (!CacheMemoryContext)
             CreateCacheMemoryContext();
  
         /*
          * reserve enough in_progress_list slots for many cases
          */
         allocsize = 4;
         in_progress_list =
             MemoryContextAlloc(CacheMemoryContext,
                                allocsize * sizeof(*in_progress_list));
         in_progress_list_maxlen = allocsize;
     }
  
     Assert(TypeCacheHash != NULL && RelIdToTypeIdCacheHash != NULL);
  
     /* Register to catch invalidation messages */
     if (in_progress_list_len >= in_progress_list_maxlen)
     {
         int         allocsize;
  
         allocsize = in_progress_list_maxlen * 2;
         in_progress_list = repalloc(in_progress_list,
                                     allocsize * sizeof(*in_progress_list));
         in_progress_list_maxlen = allocsize;
     }
     in_progress_offset = in_progress_list_len++;
     in_progress_list[in_progress_offset] = type_id;
  
     /* Try to look up an existing entry */
     typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
                                               &type_id,
                                               HASH_FIND, NULL);
     if (typentry == NULL)
     {
         /*
          * If we didn't find one, we want to make one.  But first look up the
          * pg_type row, just to make sure we don't make a cache entry for an
          * invalid type OID.  If the type OID is not valid, present a
          * user-facing error, since some code paths such as domain_in() allow
          * this function to be reached with a user-supplied OID.
          */
         HeapTuple   tp;
         Form_pg_type typtup;
  
         tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
         if (!HeapTupleIsValid(tp))
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("type with OID %u does not exist", type_id)));
         typtup = (Form_pg_type) GETSTRUCT(tp);
         if (!typtup->typisdefined)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("type \"%s\" is only a shell",
                             NameStr(typtup->typname))));
  
         /* Now make the typcache entry */
         typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
                                                   &type_id,
                                                   HASH_ENTER, &found);
         Assert(!found);         /* it wasn't there a moment ago */
  
         MemSet(typentry, 0, sizeof(TypeCacheEntry));
  
         /* These fields can never change, by definition */
         typentry->type_id = type_id;
         typentry->type_id_hash = get_hash_value(TypeCacheHash, &type_id);
  
         /* Keep this part in sync with the code below */
         typentry->typlen = typtup->typlen;
         typentry->typbyval = typtup->typbyval;
         typentry->typalign = typtup->typalign;
         typentry->typstorage = typtup->typstorage;
         typentry->typtype = typtup->typtype;
         typentry->typrelid = typtup->typrelid;
         typentry->typsubscript = typtup->typsubscript;
         typentry->typelem = typtup->typelem;
         typentry->typcollation = typtup->typcollation;
         typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
  
         /* If it's a domain, immediately thread it into the domain cache list */
         if (typentry->typtype == TYPTYPE_DOMAIN)
         {
             typentry->nextDomain = firstDomainTypeEntry;
             firstDomainTypeEntry = typentry;
         }
  
         ReleaseSysCache(tp);
     }
     else if (!(typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
     {
         /*
          * We have an entry, but its pg_type row got changed, so reload the
          * data obtained directly from pg_type.
          */
         HeapTuple   tp;
         Form_pg_type typtup;
  
         tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
         if (!HeapTupleIsValid(tp))
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("type with OID %u does not exist", type_id)));
         typtup = (Form_pg_type) GETSTRUCT(tp);
         if (!typtup->typisdefined)
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_OBJECT),
                      errmsg("type \"%s\" is only a shell",
                             NameStr(typtup->typname))));
  
         /*
          * Keep this part in sync with the code above.  Many of these fields
          * shouldn't ever change, particularly typtype, but copy 'em anyway.
          */
         typentry->typlen = typtup->typlen;
         typentry->typbyval = typtup->typbyval;
         typentry->typalign = typtup->typalign;
         typentry->typstorage = typtup->typstorage;
         typentry->typtype = typtup->typtype;
         typentry->typrelid = typtup->typrelid;
         typentry->typsubscript = typtup->typsubscript;
         typentry->typelem = typtup->typelem;
         typentry->typcollation = typtup->typcollation;
         typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
  
         ReleaseSysCache(tp);
     }
  
     /*
      * Look up opclasses if we haven't already and any dependent info is
      * requested.
      */
     if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_LT_OPR | TYPECACHE_GT_OPR |
                   TYPECACHE_CMP_PROC |
                   TYPECACHE_EQ_OPR_FINFO | TYPECACHE_CMP_PROC_FINFO |
                   TYPECACHE_BTREE_OPFAMILY)) &&
         !(typentry->flags & TCFLAGS_CHECKED_BTREE_OPCLASS))
     {
         Oid         opclass;
  
         opclass = GetDefaultOpClass(type_id, BTREE_AM_OID);
         if (OidIsValid(opclass))
         {
             typentry->btree_opf = get_opclass_family(opclass);
             typentry->btree_opintype = get_opclass_input_type(opclass);
         }
         else
         {
             typentry->btree_opf = typentry->btree_opintype = InvalidOid;
         }
  
         /*
          * Reset information derived from btree opclass.  Note in particular
          * that we'll redetermine the eq_opr even if we previously found one;
          * this matters in case a btree opclass has been added to a type that
          * previously had only a hash opclass.
          */
         typentry->flags &= ~(TCFLAGS_CHECKED_EQ_OPR |
                              TCFLAGS_CHECKED_LT_OPR |
                              TCFLAGS_CHECKED_GT_OPR |
                              TCFLAGS_CHECKED_CMP_PROC);
         typentry->flags |= TCFLAGS_CHECKED_BTREE_OPCLASS;
     }
  
     /*
      * If we need to look up equality operator, and there's no btree opclass,
      * force lookup of hash opclass.
      */
     if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
         !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR) &&
         typentry->btree_opf == InvalidOid)
         flags |= TYPECACHE_HASH_OPFAMILY;
  
     if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO |
                   TYPECACHE_HASH_EXTENDED_PROC |
                   TYPECACHE_HASH_EXTENDED_PROC_FINFO |
                   TYPECACHE_HASH_OPFAMILY)) &&
         !(typentry->flags & TCFLAGS_CHECKED_HASH_OPCLASS))
     {
         Oid         opclass;
  
         opclass = GetDefaultOpClass(type_id, HASH_AM_OID);
         if (OidIsValid(opclass))
         {
             typentry->hash_opf = get_opclass_family(opclass);
             typentry->hash_opintype = get_opclass_input_type(opclass);
         }
         else
         {
             typentry->hash_opf = typentry->hash_opintype = InvalidOid;
         }
  
         /*
          * Reset information derived from hash opclass.  We do *not* reset the
          * eq_opr; if we already found one from the btree opclass, that
          * decision is still good.
          */
         typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
                              TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
         typentry->flags |= TCFLAGS_CHECKED_HASH_OPCLASS;
     }
  
     /*
      * Look for requested operators and functions, if we haven't already.
      */
     if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
         !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR))
     {
         Oid         eq_opr = InvalidOid;
  
         if (typentry->btree_opf != InvalidOid)
             eq_opr = get_opfamily_member(typentry->btree_opf,
                                          typentry->btree_opintype,
                                          typentry->btree_opintype,
                                          BTEqualStrategyNumber);
         if (eq_opr == InvalidOid &&
             typentry->hash_opf != InvalidOid)
             eq_opr = get_opfamily_member(typentry->hash_opf,
                                          typentry->hash_opintype,
                                          typentry->hash_opintype,
                                          HTEqualStrategyNumber);
  
         /*
          * If the proposed equality operator is array_eq or record_eq, check
          * to see if the element type or column types support equality.  If
          * not, array_eq or record_eq would fail at runtime, so we don't want
          * to report that the type has equality.  (We can omit similar
          * checking for ranges and multiranges because ranges can't be created
          * in the first place unless their subtypes support equality.)
          */
         if (eq_opr == ARRAY_EQ_OP &&
             !array_element_has_equality(typentry))
             eq_opr = InvalidOid;
         else if (eq_opr == RECORD_EQ_OP &&
                  !record_fields_have_equality(typentry))
             eq_opr = InvalidOid;
  
         /* Force update of eq_opr_finfo only if we're changing state */
         if (typentry->eq_opr != eq_opr)
             typentry->eq_opr_finfo.fn_oid = InvalidOid;
  
         typentry->eq_opr = eq_opr;
  
         /*
          * Reset info about hash functions whenever we pick up new info about
          * equality operator.  This is so we can ensure that the hash
          * functions match the operator.
          */
         typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
                              TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
         typentry->flags |= TCFLAGS_CHECKED_EQ_OPR;
     }
     if ((flags & TYPECACHE_LT_OPR) &&
         !(typentry->flags & TCFLAGS_CHECKED_LT_OPR))
     {
         Oid         lt_opr = InvalidOid;
  
         if (typentry->btree_opf != InvalidOid)
             lt_opr = get_opfamily_member(typentry->btree_opf,
                                          typentry->btree_opintype,
                                          typentry->btree_opintype,
                                          BTLessStrategyNumber);
  
         /*
          * As above, make sure array_cmp or record_cmp will succeed; but again
          * we need no special check for ranges or multiranges.
          */
         if (lt_opr == ARRAY_LT_OP &&
             !array_element_has_compare(typentry))
             lt_opr = InvalidOid;
         else if (lt_opr == RECORD_LT_OP &&
                  !record_fields_have_compare(typentry))
             lt_opr = InvalidOid;
  
         typentry->lt_opr = lt_opr;
         typentry->flags |= TCFLAGS_CHECKED_LT_OPR;
     }
     if ((flags & TYPECACHE_GT_OPR) &&
         !(typentry->flags & TCFLAGS_CHECKED_GT_OPR))
     {
         Oid         gt_opr = InvalidOid;
  
         if (typentry->btree_opf != InvalidOid)
             gt_opr = get_opfamily_member(typentry->btree_opf,
                                          typentry->btree_opintype,
                                          typentry->btree_opintype,
                                          BTGreaterStrategyNumber);
  
         /*
          * As above, make sure array_cmp or record_cmp will succeed; but again
          * we need no special check for ranges or multiranges.
          */
         if (gt_opr == ARRAY_GT_OP &&
             !array_element_has_compare(typentry))
             gt_opr = InvalidOid;
         else if (gt_opr == RECORD_GT_OP &&
                  !record_fields_have_compare(typentry))
             gt_opr = InvalidOid;
  
         typentry->gt_opr = gt_opr;
         typentry->flags |= TCFLAGS_CHECKED_GT_OPR;
     }
     if ((flags & (TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO)) &&
         !(typentry->flags & TCFLAGS_CHECKED_CMP_PROC))
     {
         Oid         cmp_proc = InvalidOid;
  
         if (typentry->btree_opf != InvalidOid)
             cmp_proc = get_opfamily_proc(typentry->btree_opf,
                                          typentry->btree_opintype,
                                          typentry->btree_opintype,
                                          BTORDER_PROC);
  
         /*
          * As above, make sure array_cmp or record_cmp will succeed; but again
          * we need no special check for ranges or multiranges.
          */
         if (cmp_proc == F_BTARRAYCMP &&
             !array_element_has_compare(typentry))
             cmp_proc = InvalidOid;
         else if (cmp_proc == F_BTRECORDCMP &&
                  !record_fields_have_compare(typentry))
             cmp_proc = InvalidOid;
  
         /* Force update of cmp_proc_finfo only if we're changing state */
         if (typentry->cmp_proc != cmp_proc)
             typentry->cmp_proc_finfo.fn_oid = InvalidOid;
  
         typentry->cmp_proc = cmp_proc;
         typentry->flags |= TCFLAGS_CHECKED_CMP_PROC;
     }
     if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO)) &&
         !(typentry->flags & TCFLAGS_CHECKED_HASH_PROC))
     {
         Oid         hash_proc = InvalidOid;
  
         /*
          * We insist that the eq_opr, if one has been determined, match the
          * hash opclass; else report there is no hash function.
          */
         if (typentry->hash_opf != InvalidOid &&
             (!OidIsValid(typentry->eq_opr) ||
              typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
                                                      typentry->hash_opintype,
                                                      typentry->hash_opintype,
                                                      HTEqualStrategyNumber)))
             hash_proc = get_opfamily_proc(typentry->hash_opf,
                                           typentry->hash_opintype,
                                           typentry->hash_opintype,
                                           HASHSTANDARD_PROC);
  
         /*
          * As above, make sure hash_array, hash_record, or hash_range will
          * succeed.
          */
         if (hash_proc == F_HASH_ARRAY &&
             !array_element_has_hashing(typentry))
             hash_proc = InvalidOid;
         else if (hash_proc == F_HASH_RECORD &&
                  !record_fields_have_hashing(typentry))
             hash_proc = InvalidOid;
         else if (hash_proc == F_HASH_RANGE &&
                  !range_element_has_hashing(typentry))
             hash_proc = InvalidOid;
  
         /*
          * Likewise for hash_multirange.
          */
         if (hash_proc == F_HASH_MULTIRANGE &&
             !multirange_element_has_hashing(typentry))
             hash_proc = InvalidOid;
  
         /* Force update of hash_proc_finfo only if we're changing state */
         if (typentry->hash_proc != hash_proc)
             typentry->hash_proc_finfo.fn_oid = InvalidOid;
  
         typentry->hash_proc = hash_proc;
         typentry->flags |= TCFLAGS_CHECKED_HASH_PROC;
     }
     if ((flags & (TYPECACHE_HASH_EXTENDED_PROC |
                   TYPECACHE_HASH_EXTENDED_PROC_FINFO)) &&
         !(typentry->flags & TCFLAGS_CHECKED_HASH_EXTENDED_PROC))
     {
         Oid         hash_extended_proc = InvalidOid;
  
         /*
          * We insist that the eq_opr, if one has been determined, match the
          * hash opclass; else report there is no hash function.
          */
         if (typentry->hash_opf != InvalidOid &&
             (!OidIsValid(typentry->eq_opr) ||
              typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
                                                      typentry->hash_opintype,
                                                      typentry->hash_opintype,
                                                      HTEqualStrategyNumber)))
             hash_extended_proc = get_opfamily_proc(typentry->hash_opf,
                                                    typentry->hash_opintype,
                                                    typentry->hash_opintype,
                                                    HASHEXTENDED_PROC);
  
         /*
          * As above, make sure hash_array_extended, hash_record_extended, or
          * hash_range_extended will succeed.
          */
         if (hash_extended_proc == F_HASH_ARRAY_EXTENDED &&
             !array_element_has_extended_hashing(typentry))
             hash_extended_proc = InvalidOid;
         else if (hash_extended_proc == F_HASH_RECORD_EXTENDED &&
                  !record_fields_have_extended_hashing(typentry))
             hash_extended_proc = InvalidOid;
         else if (hash_extended_proc == F_HASH_RANGE_EXTENDED &&
                  !range_element_has_extended_hashing(typentry))
             hash_extended_proc = InvalidOid;
  
         /*
          * Likewise for hash_multirange_extended.
          */
         if (hash_extended_proc == F_HASH_MULTIRANGE_EXTENDED &&
             !multirange_element_has_extended_hashing(typentry))
             hash_extended_proc = InvalidOid;
  
         /* Force update of proc finfo only if we're changing state */
         if (typentry->hash_extended_proc != hash_extended_proc)
             typentry->hash_extended_proc_finfo.fn_oid = InvalidOid;
  
         typentry->hash_extended_proc = hash_extended_proc;
         typentry->flags |= TCFLAGS_CHECKED_HASH_EXTENDED_PROC;
     }
  
     /*
      * Set up fmgr lookup info as requested
      *
      * Note: we tell fmgr the finfo structures live in CacheMemoryContext,
      * which is not quite right (they're really in the hash table's private
      * memory context) but this will do for our purposes.
      *
      * Note: the code above avoids invalidating the finfo structs unless the
      * referenced operator/function OID actually changes.  This is to prevent
      * unnecessary leakage of any subsidiary data attached to an finfo, since
      * that would cause session-lifespan memory leaks.
      */
     if ((flags & TYPECACHE_EQ_OPR_FINFO) &&
         typentry->eq_opr_finfo.fn_oid == InvalidOid &&
         typentry->eq_opr != InvalidOid)
     {
         Oid         eq_opr_func;
  
         eq_opr_func = get_opcode(typentry->eq_opr);
         if (eq_opr_func != InvalidOid)
             fmgr_info_cxt(eq_opr_func, &typentry->eq_opr_finfo,
                           CacheMemoryContext);
     }
     if ((flags & TYPECACHE_CMP_PROC_FINFO) &&
         typentry->cmp_proc_finfo.fn_oid == InvalidOid &&
         typentry->cmp_proc != InvalidOid)
     {
         fmgr_info_cxt(typentry->cmp_proc, &typentry->cmp_proc_finfo,
                       CacheMemoryContext);
     }
     if ((flags & TYPECACHE_HASH_PROC_FINFO) &&
         typentry->hash_proc_finfo.fn_oid == InvalidOid &&
         typentry->hash_proc != InvalidOid)
     {
         fmgr_info_cxt(typentry->hash_proc, &typentry->hash_proc_finfo,
                       CacheMemoryContext);
     }
     if ((flags & TYPECACHE_HASH_EXTENDED_PROC_FINFO) &&
         typentry->hash_extended_proc_finfo.fn_oid == InvalidOid &&
         typentry->hash_extended_proc != InvalidOid)
     {
         fmgr_info_cxt(typentry->hash_extended_proc,
                       &typentry->hash_extended_proc_finfo,
                       CacheMemoryContext);
     }
  
     /*
      * If it's a composite type (row type), get tupdesc if requested
      */
     if ((flags & TYPECACHE_TUPDESC) &&
         typentry->tupDesc == NULL &&
         typentry->typtype == TYPTYPE_COMPOSITE)
     {
         load_typcache_tupdesc(typentry);
     }
  
     /*
      * If requested, get information about a range type
      *
      * This includes making sure that the basic info about the range element
      * type is up-to-date.
      */
     if ((flags & TYPECACHE_RANGE_INFO) &&
         typentry->typtype == TYPTYPE_RANGE)
     {
         if (typentry->rngelemtype == NULL)
             load_rangetype_info(typentry);
         else if (!(typentry->rngelemtype->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
             (void) lookup_type_cache(typentry->rngelemtype->type_id, 0);
     }
  
     /*
      * If requested, get information about a multirange type
      */
     if ((flags & TYPECACHE_MULTIRANGE_INFO) &&
         typentry->rngtype == NULL &&
         typentry->typtype == TYPTYPE_MULTIRANGE)
     {
         load_multirangetype_info(typentry);
     }
  
     /*
      * If requested, get information about a domain type
      */
     if ((flags & TYPECACHE_DOMAIN_BASE_INFO) &&
         typentry->domainBaseType == InvalidOid &&
         typentry->typtype == TYPTYPE_DOMAIN)
     {
         typentry->domainBaseTypmod = -1;
         typentry->domainBaseType =
             getBaseTypeAndTypmod(type_id, &typentry->domainBaseTypmod);
     }
     if ((flags & TYPECACHE_DOMAIN_CONSTR_INFO) &&
         (typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
         typentry->typtype == TYPTYPE_DOMAIN)
     {
         load_domaintype_info(typentry);
     }
  
     INJECTION_POINT("typecache-before-rel-type-cache-insert");
  
     Assert(in_progress_offset + 1 == in_progress_list_len);
     in_progress_list_len--;
  
     insert_rel_type_cache_if_needed(typentry);
  
     return typentry;
 }

References array_element_has_compare(), array_element_has_equality(), array_element_has_extended_hashing(), array_element_has_hashing(), Assert, BTEqualStrategyNumber, BTGreaterStrategyNumber, BTLessStrategyNumber, BTORDER_PROC, TypeCacheEntry::btree_opf, TypeCacheEntry::btree_opintype, CacheMemoryContext, CacheRegisterRelcacheCallback(), CacheRegisterSyscacheCallback(), TypeCacheEntry::cmp_proc, TypeCacheEntry::cmp_proc_finfo, CreateCacheMemoryContext(), ctl, TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, TypeCacheEntry::eq_opr, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, firstDomainTypeEntry, TypeCacheEntry::flags, fmgr_info_cxt(), FmgrInfo::fn_oid, get_hash_value(), get_opclass_family(), get_opclass_input_type(), get_opcode(), get_opfamily_member(), get_opfamily_proc(), getBaseTypeAndTypmod(), GetDefaultOpClass(), GETSTRUCT, TypeCacheEntry::gt_opr, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_extended_proc_finfo, HASH_FIND, HASH_FUNCTION, TypeCacheEntry::hash_opf, TypeCacheEntry::hash_opintype, TypeCacheEntry::hash_proc, TypeCacheEntry::hash_proc_finfo, hash_search(), HASHEXTENDED_PROC, HASHSTANDARD_PROC, HeapTupleIsValid, HTEqualStrategyNumber, in_progress_list, in_progress_list_len, in_progress_list_maxlen, INJECTION_POINT, insert_rel_type_cache_if_needed(), InvalidOid, load_domaintype_info(), load_multirangetype_info(), load_rangetype_info(), load_typcache_tupdesc(), TypeCacheEntry::lt_opr, MemoryContextAlloc(), MemSet, multirange_element_has_extended_hashing(), multirange_element_has_hashing(), NameStr, TypeCacheEntry::nextDomain, ObjectIdGetDatum(), OidIsValid, range_element_has_extended_hashing(), range_element_has_hashing(), record_fields_have_compare(), record_fields_have_equality(), record_fields_have_extended_hashing(), record_fields_have_hashing(), ReleaseSysCache(), RelIdToTypeIdCacheHash, repalloc(), TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, SearchSysCache1(), TCFLAGS_CHECKED_BTREE_OPCLASS, TCFLAGS_CHECKED_CMP_PROC, TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, TCFLAGS_CHECKED_EQ_OPR, TCFLAGS_CHECKED_GT_OPR, TCFLAGS_CHECKED_HASH_EXTENDED_PROC, TCFLAGS_CHECKED_HASH_OPCLASS, TCFLAGS_CHECKED_HASH_PROC, TCFLAGS_CHECKED_LT_OPR, TCFLAGS_HAVE_PG_TYPE_DATA, TypeCacheEntry::tupDesc, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::typcollation, type_cache_syshash(), TypeCacheEntry::type_id, TypeCacheEntry::type_id_hash, TYPECACHE_BTREE_OPFAMILY, TYPECACHE_CMP_PROC, TYPECACHE_CMP_PROC_FINFO, TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_DOMAIN_CONSTR_INFO, TYPECACHE_EQ_OPR, TYPECACHE_EQ_OPR_FINFO, TYPECACHE_GT_OPR, TYPECACHE_HASH_EXTENDED_PROC, TYPECACHE_HASH_EXTENDED_PROC_FINFO, TYPECACHE_HASH_OPFAMILY, TYPECACHE_HASH_PROC, TYPECACHE_HASH_PROC_FINFO, TYPECACHE_LT_OPR, TYPECACHE_MULTIRANGE_INFO, TYPECACHE_RANGE_INFO, TYPECACHE_TUPDESC, TypeCacheConstrCallback(), TypeCacheHash, TypeCacheOpcCallback(), TypeCacheRelCallback(), TypeCacheTypCallback(), TypeCacheEntry::typelem, TypeCacheEntry::typlen, TypeCacheEntry::typrelid, TypeCacheEntry::typstorage, TypeCacheEntry::typsubscript, and TypeCacheEntry::typtype.

Referenced by analyzeCTE(), appendOrderBySuffix(), array_cmp(), array_contain_compare(), array_eq(), array_position_common(), array_positions(), array_replace_internal(), array_reverse(), array_sample(), array_shuffle(), array_typanalyze(), assign_record_type_identifier(), brin_bloom_opcinfo(), brin_inclusion_opcinfo(), brin_minmax_multi_opcinfo(), brin_minmax_opcinfo(), build_datatype(), build_mss(), cache_array_element_properties(), cache_multirange_element_properties(), cache_range_element_properties(), cache_record_field_properties(), calc_arraycontsel(), check_exclusion_or_unique_constraint(), check_memoizable(), contain_leaked_vars_walker(), CreateStatistics(), dependency_degree(), domain_state_setup(), DomainHasConstraints(), enum_cmp_internal(), ExecInitExprRec(), find_simplified_clause(), foreign_expr_walker(), get_attr_stat_type(), get_cached_rowtype(), get_elem_stat_type(), get_multirange_io_data(), get_range_io_data(), get_rule_orderby(), get_sort_group_operators(), hash_array(), hash_array_extended(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), InitDomainConstraintRef(), initGinState(), load_multirangetype_info(), load_rangetype_info(), lookup_rowtype_tupdesc_domain(), lookup_rowtype_tupdesc_internal(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), multirange_get_typcache(), multirange_unnest(), ndistinct_for_combination(), op_hashjoinable(), op_mergejoinable(), paraminfo_get_equal_hashops(), PLy_input_setup_func(), PLy_output_setup_func(), range_get_typcache(), record_cmp(), record_eq(), revalidate_rectypeid(), scalararraysel(), scalararraysel_containment(), show_sortorder_options(), statext_mcv_serialize(), tuples_equal(), and width_bucket_array().

◆ SharedRecordTypmodRegistryAttach()

void SharedRecordTypmodRegistryAttach ( SharedRecordTypmodRegistry * registry )

Definition at line 2294 of file typcache.c.

 {
     MemoryContext old_context;
     dshash_table *record_table;
     dshash_table *typmod_table;
  
     Assert(IsParallelWorker());
  
     /* We can't already be attached to a shared registry. */
     Assert(CurrentSession != NULL);
     Assert(CurrentSession->segment != NULL);
     Assert(CurrentSession->area != NULL);
     Assert(CurrentSession->shared_typmod_registry == NULL);
     Assert(CurrentSession->shared_record_table == NULL);
     Assert(CurrentSession->shared_typmod_table == NULL);
  
     /*
      * We can't already have typmods in our local cache, because they'd clash
      * with those imported by SharedRecordTypmodRegistryInit.  This should be
      * a freshly started parallel worker.  If we ever support worker
      * recycling, a worker would need to zap its local cache in between
      * servicing different queries, in order to be able to call this and
      * synchronize typmods with a new leader; but that's problematic because
      * we can't be very sure that record-typmod-related state hasn't escaped
      * to anywhere else in the process.
      */
     Assert(NextRecordTypmod == 0);
  
     old_context = MemoryContextSwitchTo(TopMemoryContext);
  
     /* Attach to the two hash tables. */
     record_table = dshash_attach(CurrentSession->area,
                                  &srtr_record_table_params,
                                  registry->record_table_handle,
                                  CurrentSession->area);
     typmod_table = dshash_attach(CurrentSession->area,
                                  &srtr_typmod_table_params,
                                  registry->typmod_table_handle,
                                  NULL);
  
     MemoryContextSwitchTo(old_context);
  
     /*
      * Set up detach hook to run at worker exit.  Currently this is the same
      * as the leader's detach hook, but in future they might need to be
      * different.
      */
     on_dsm_detach(CurrentSession->segment,
                   shared_record_typmod_registry_detach,
                   PointerGetDatum(registry));
  
     /*
      * Set up the session state that will tell assign_record_type_typmod and
      * lookup_rowtype_tupdesc_internal about the shared registry.
      */
     CurrentSession->shared_typmod_registry = registry;
     CurrentSession->shared_record_table = record_table;
     CurrentSession->shared_typmod_table = typmod_table;
 }

References Session::area, Assert, CurrentSession, dshash_attach(), IsParallelWorker, MemoryContextSwitchTo(), NextRecordTypmod, on_dsm_detach(), PointerGetDatum(), SharedRecordTypmodRegistry::record_table_handle, Session::segment, Session::shared_record_table, shared_record_typmod_registry_detach(), Session::shared_typmod_registry, Session::shared_typmod_table, srtr_record_table_params, srtr_typmod_table_params, TopMemoryContext, and SharedRecordTypmodRegistry::typmod_table_handle.

Referenced by AttachSession().

◆ SharedRecordTypmodRegistryEstimate()

size_t SharedRecordTypmodRegistryEstimate ( void )

Definition at line 2173 of file typcache.c.

 {
     return sizeof(SharedRecordTypmodRegistry);
 }

Referenced by GetSessionDsmHandle().

◆ SharedRecordTypmodRegistryInit()

void SharedRecordTypmodRegistryInit	(	SharedRecordTypmodRegistry *	registry,
		dsm_segment *	segment,
		dsa_area *	area
	)

Definition at line 2195 of file typcache.c.

 {
     MemoryContext old_context;
     dshash_table *record_table;
     dshash_table *typmod_table;
     int32       typmod;
  
     Assert(!IsParallelWorker());
  
     /* We can't already be attached to a shared registry. */
     Assert(CurrentSession->shared_typmod_registry == NULL);
     Assert(CurrentSession->shared_record_table == NULL);
     Assert(CurrentSession->shared_typmod_table == NULL);
  
     old_context = MemoryContextSwitchTo(TopMemoryContext);
  
     /* Create the hash table of tuple descriptors indexed by themselves. */
     record_table = dshash_create(area, &srtr_record_table_params, area);
  
     /* Create the hash table of tuple descriptors indexed by typmod. */
     typmod_table = dshash_create(area, &srtr_typmod_table_params, NULL);
  
     MemoryContextSwitchTo(old_context);
  
     /* Initialize the SharedRecordTypmodRegistry. */
     registry->record_table_handle = dshash_get_hash_table_handle(record_table);
     registry->typmod_table_handle = dshash_get_hash_table_handle(typmod_table);
     pg_atomic_init_u32(&registry->next_typmod, NextRecordTypmod);
  
     /*
      * Copy all entries from this backend's private registry into the shared
      * registry.
      */
     for (typmod = 0; typmod < NextRecordTypmod; ++typmod)
     {
         SharedTypmodTableEntry *typmod_table_entry;
         SharedRecordTableEntry *record_table_entry;
         SharedRecordTableKey record_table_key;
         dsa_pointer shared_dp;
         TupleDesc   tupdesc;
         bool        found;
  
         tupdesc = RecordCacheArray[typmod].tupdesc;
         if (tupdesc == NULL)
             continue;
  
         /* Copy the TupleDesc into shared memory. */
         shared_dp = share_tupledesc(area, tupdesc, typmod);
  
         /* Insert into the typmod table. */
         typmod_table_entry = dshash_find_or_insert(typmod_table,
                                                    &tupdesc->tdtypmod,
                                                    &found);
         if (found)
             elog(ERROR, "cannot create duplicate shared record typmod");
         typmod_table_entry->typmod = tupdesc->tdtypmod;
         typmod_table_entry->shared_tupdesc = shared_dp;
         dshash_release_lock(typmod_table, typmod_table_entry);
  
         /* Insert into the record table. */
         record_table_key.shared = false;
         record_table_key.u.local_tupdesc = tupdesc;
         record_table_entry = dshash_find_or_insert(record_table,
                                                    &record_table_key,
                                                    &found);
         if (!found)
         {
             record_table_entry->key.shared = true;
             record_table_entry->key.u.shared_tupdesc = shared_dp;
         }
         dshash_release_lock(record_table, record_table_entry);
     }
  
     /*
      * Set up the global state that will tell assign_record_type_typmod and
      * lookup_rowtype_tupdesc_internal about the shared registry.
      */
     CurrentSession->shared_record_table = record_table;
     CurrentSession->shared_typmod_table = typmod_table;
     CurrentSession->shared_typmod_registry = registry;
  
     /*
      * We install a detach hook in the leader, but only to handle cleanup on
      * failure during GetSessionDsmHandle().  Once GetSessionDsmHandle() pins
      * the memory, the leader process will use a shared registry until it
      * exits.
      */
     on_dsm_detach(segment, shared_record_typmod_registry_detach, (Datum) 0);
 }

References Assert, CurrentSession, dshash_create(), dshash_find_or_insert(), dshash_get_hash_table_handle(), dshash_release_lock(), elog, ERROR, IsParallelWorker, SharedRecordTableEntry::key, SharedRecordTableKey::local_tupdesc, MemoryContextSwitchTo(), SharedRecordTypmodRegistry::next_typmod, NextRecordTypmod, on_dsm_detach(), pg_atomic_init_u32(), SharedRecordTypmodRegistry::record_table_handle, RecordCacheArray, share_tupledesc(), SharedRecordTableKey::shared, Session::shared_record_table, shared_record_typmod_registry_detach(), SharedRecordTableKey::shared_tupdesc, SharedTypmodTableEntry::shared_tupdesc, Session::shared_typmod_registry, Session::shared_typmod_table, srtr_record_table_params, srtr_typmod_table_params, TupleDescData::tdtypmod, TopMemoryContext, RecordCacheArrayEntry::tupdesc, SharedTypmodTableEntry::typmod, SharedRecordTypmodRegistry::typmod_table_handle, and SharedRecordTableKey::u.