typcache.h File Reference

#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:

Go to the source code of 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 26 of file typcache.h.

DomainConstraintRef

typedef struct DomainConstraintRef DomainConstraintRef

SharedRecordTypmodRegistry

typedef struct SharedRecordTypmodRegistry SharedRecordTypmodRegistry

Definition at line 176 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(), lookup_type_cache(), 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(), GinBufferInit(), hash_array(), hash_array_extended(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), InitDomainConstraintRef(), initGinState(), IsIndexUsableForReplicaIdentityFull(), load_multirangetype_info(), load_rangetype_info(), lookup_rowtype_tupdesc_domain(), lookup_rowtype_tupdesc_internal(), lookup_type_cache(), 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(), tuplesort_begin_index_gin(), 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.

Referenced by GetSessionDsmHandle().

UpdateDomainConstraintRef()

void UpdateDomainConstraintRef

(

DomainConstraintRef *

ref

)

Definition at line 1438 of file typcache.c.

{
    TypeCacheEntry *typentry = ref->tcache;
 
    /* Make sure typcache entry's data is up to date */
    if ((typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
        typentry->typtype == TYPTYPE_DOMAIN)
        load_domaintype_info(typentry);
 
    /* Transfer to ref object if there's new info, adjusting refcounts */
    if (ref->dcc != typentry->domainData)
    {
        /* Paranoia --- be sure link is nulled before trying to release */
        DomainConstraintCache *dcc = ref->dcc;
 
        if (dcc)
        {
            /*
             * Note: we just leak the previous list of executable domain
             * constraints.  Alternatively, we could keep those in a child
             * context of ref->refctx and free that context at this point.
             * However, in practice this code path will be taken so seldom
             * that the extra bookkeeping for a child context doesn't seem
             * worthwhile; we'll just allow a leak for the lifespan of refctx.
             */
            ref->constraints = NIL;
            ref->dcc = NULL;
            decr_dcc_refcount(dcc);
        }
        dcc = typentry->domainData;
        if (dcc)
        {
            ref->dcc = dcc;
            dcc->dccRefCount++;
            if (ref->need_exprstate)
                ref->constraints = prep_domain_constraints(dcc->constraints,
                                                           ref->refctx);
            else
                ref->constraints = dcc->constraints;
        }
    }
}

References DomainConstraintCache::constraints, DomainConstraintRef::constraints, DomainConstraintRef::dcc, DomainConstraintCache::dccRefCount, decr_dcc_refcount(), TypeCacheEntry::domainData, TypeCacheEntry::flags, load_domaintype_info(), DomainConstraintRef::need_exprstate, NIL, prep_domain_constraints(), DomainConstraintRef::refctx, DomainConstraintRef::tcache, TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, and TypeCacheEntry::typtype.

Referenced by domain_check_input().