PostgreSQL Source Code  git master
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

TypeCacheEntrylookup_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 *)
 

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

Definition at line 1 of file typcache.h.

◆ DomainConstraintRef

◆ SharedRecordTypmodRegistry

Definition at line 1 of file typcache.h.

◆ TypeCacheEntry

Function Documentation

◆ assign_record_type_identifier()

uint64 assign_record_type_identifier ( Oid  type_id,
int32  typmod 
)

Definition at line 2045 of file typcache.c.

2046 {
2047  if (type_id != RECORDOID)
2048  {
2049  /*
2050  * It's a named composite type, so use the regular typcache.
2051  */
2052  TypeCacheEntry *typentry;
2053 
2054  typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
2055  if (typentry->tupDesc == NULL)
2056  ereport(ERROR,
2057  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
2058  errmsg("type %s is not composite",
2059  format_type_be(type_id))));
2060  Assert(typentry->tupDesc_identifier != 0);
2061  return typentry->tupDesc_identifier;
2062  }
2063  else
2064  {
2065  /*
2066  * It's a transient record type, so look in our record-type table.
2067  */
2068  if (typmod >= 0 && typmod < RecordCacheArrayLen &&
2069  RecordCacheArray[typmod].tupdesc != NULL)
2070  {
2071  Assert(RecordCacheArray[typmod].id != 0);
2072  return RecordCacheArray[typmod].id;
2073  }
2074 
2075  /* For anonymous or unrecognized record type, generate a new ID */
2076  return ++tupledesc_id_counter;
2077  }
2078 }
#define Assert(condition)
Definition: c.h:858
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
uint64 tupDesc_identifier
Definition: typcache.h:90
TupleDesc tupDesc
Definition: typcache.h:89
static RecordCacheArrayEntry * RecordCacheArray
Definition: typcache.c:285
static int32 RecordCacheArrayLen
Definition: typcache.c:286
static uint64 tupledesc_id_counter
Definition: typcache.c:294
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition: typcache.c:346
#define TYPECACHE_TUPDESC
Definition: typcache.h:145

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 1953 of file typcache.c.

1954 {
1955  RecordCacheEntry *recentry;
1956  TupleDesc entDesc;
1957  bool found;
1958  MemoryContext oldcxt;
1959 
1960  Assert(tupDesc->tdtypeid == RECORDOID);
1961 
1962  if (RecordCacheHash == NULL)
1963  {
1964  /* First time through: initialize the hash table */
1965  HASHCTL ctl;
1966 
1967  ctl.keysize = sizeof(TupleDesc); /* just the pointer */
1968  ctl.entrysize = sizeof(RecordCacheEntry);
1971  RecordCacheHash = hash_create("Record information cache", 64,
1972  &ctl,
1974 
1975  /* Also make sure CacheMemoryContext exists */
1976  if (!CacheMemoryContext)
1978  }
1979 
1980  /*
1981  * Find a hashtable entry for this tuple descriptor. We don't use
1982  * HASH_ENTER yet, because if it's missing, we need to make sure that all
1983  * the allocations succeed before we create the new entry.
1984  */
1986  &tupDesc,
1987  HASH_FIND, &found);
1988  if (found && recentry->tupdesc != NULL)
1989  {
1990  tupDesc->tdtypmod = recentry->tupdesc->tdtypmod;
1991  return;
1992  }
1993 
1994  /* Not present, so need to manufacture an entry */
1996 
1997  /* Look in the SharedRecordTypmodRegistry, if attached */
1998  entDesc = find_or_make_matching_shared_tupledesc(tupDesc);
1999  if (entDesc == NULL)
2000  {
2001  /*
2002  * Make sure we have room before we CreateTupleDescCopy() or advance
2003  * NextRecordTypmod.
2004  */
2006 
2007  /* Reference-counted local cache only. */
2008  entDesc = CreateTupleDescCopy(tupDesc);
2009  entDesc->tdrefcount = 1;
2010  entDesc->tdtypmod = NextRecordTypmod++;
2011  }
2012  else
2013  {
2015  }
2016 
2017  RecordCacheArray[entDesc->tdtypmod].tupdesc = entDesc;
2018 
2019  /* Assign a unique tupdesc identifier, too. */
2021 
2022  /* Fully initialized; create the hash table entry */
2024  &tupDesc,
2025  HASH_ENTER, NULL);
2026  recentry->tupdesc = entDesc;
2027 
2028  /* Update the caller's tuple descriptor. */
2029  tupDesc->tdtypmod = entDesc->tdtypmod;
2030 
2031  MemoryContextSwitchTo(oldcxt);
2032 }
void CreateCacheMemoryContext(void)
Definition: catcache.c:679
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_COMPARE
Definition: hsearch.h:99
#define HASH_FUNCTION
Definition: hsearch.h:98
MemoryContext CacheMemoryContext
Definition: mcxt.c:152
MemoryContextSwitchTo(old_ctx)
tree ctl
Definition: radixtree.h:1851
TupleDesc tupdesc
Definition: typcache.c:159
int tdrefcount
Definition: tupdesc.h:84
int32 tdtypmod
Definition: tupdesc.h:83
Oid tdtypeid
Definition: tupdesc.h:82
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:133
struct TupleDescData * TupleDesc
Definition: tupdesc.h:89
static TupleDesc find_or_make_matching_shared_tupledesc(TupleDesc tupdesc)
Definition: typcache.c:2756
static int32 NextRecordTypmod
Definition: typcache.c:287
static HTAB * RecordCacheHash
Definition: typcache.c:276
struct RecordCacheEntry RecordCacheEntry
static int record_type_typmod_compare(const void *a, const void *b, size_t size)
Definition: typcache.c:1937
static void ensure_record_cache_typmod_slot_exists(int32 typmod)
Definition: typcache.c:1710
static uint32 record_type_typmod_hash(const void *data, size_t size)
Definition: typcache.c:1926

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().

◆ compare_values_of_enum()

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

Definition at line 2477 of file typcache.c.

2478 {
2479  TypeCacheEnumData *enumdata;
2480  EnumItem *item1;
2481  EnumItem *item2;
2482 
2483  /*
2484  * Equal OIDs are certainly equal --- this case was probably handled by
2485  * our caller, but we may as well check.
2486  */
2487  if (arg1 == arg2)
2488  return 0;
2489 
2490  /* Load up the cache if first time through */
2491  if (tcache->enumData == NULL)
2492  load_enum_cache_data(tcache);
2493  enumdata = tcache->enumData;
2494 
2495  /*
2496  * If both OIDs are known-sorted, we can just compare them directly.
2497  */
2498  if (enum_known_sorted(enumdata, arg1) &&
2499  enum_known_sorted(enumdata, arg2))
2500  {
2501  if (arg1 < arg2)
2502  return -1;
2503  else
2504  return 1;
2505  }
2506 
2507  /*
2508  * Slow path: we have to identify their actual sort-order positions.
2509  */
2510  item1 = find_enumitem(enumdata, arg1);
2511  item2 = find_enumitem(enumdata, arg2);
2512 
2513  if (item1 == NULL || item2 == NULL)
2514  {
2515  /*
2516  * We couldn't find one or both values. That means the enum has
2517  * changed under us, so re-initialize the cache and try again. We
2518  * don't bother retrying the known-sorted case in this path.
2519  */
2520  load_enum_cache_data(tcache);
2521  enumdata = tcache->enumData;
2522 
2523  item1 = find_enumitem(enumdata, arg1);
2524  item2 = find_enumitem(enumdata, arg2);
2525 
2526  /*
2527  * If we still can't find the values, complain: we must have corrupt
2528  * data.
2529  */
2530  if (item1 == NULL)
2531  elog(ERROR, "enum value %u not found in cache for enum %s",
2532  arg1, format_type_be(tcache->type_id));
2533  if (item2 == NULL)
2534  elog(ERROR, "enum value %u not found in cache for enum %s",
2535  arg2, format_type_be(tcache->type_id));
2536  }
2537 
2538  if (item1->sort_order < item2->sort_order)
2539  return -1;
2540  else if (item1->sort_order > item2->sort_order)
2541  return 1;
2542  else
2543  return 0;
2544 }
#define elog(elevel,...)
Definition: elog.h:224
float4 sort_order
Definition: typcache.c:135
struct TypeCacheEnumData * enumData
Definition: typcache.h:130
static void load_enum_cache_data(TypeCacheEntry *tcache)
Definition: typcache.c:2550
static EnumItem * find_enumitem(TypeCacheEnumData *enumdata, Oid arg)
Definition: typcache.c:2705
static bool enum_known_sorted(TypeCacheEnumData *enumdata, Oid arg)
Definition: typcache.c:2448

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 1400 of file typcache.c.

1401 {
1402  TypeCacheEntry *typentry;
1403 
1404  /*
1405  * Note: a side effect is to cause the typcache's domain data to become
1406  * valid. This is fine since we'll likely need it soon if there is any.
1407  */
1408  typentry = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
1409 
1410  return (typentry->domainData != NULL);
1411 }
DomainConstraintCache * domainData
Definition: typcache.h:121
#define TYPECACHE_DOMAIN_CONSTR_INFO
Definition: typcache.h:150

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

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

◆ InitDomainConstraintRef()

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

Definition at line 1313 of file typcache.c.

1315 {
1316  /* Look up the typcache entry --- we assume it survives indefinitely */
1318  ref->need_exprstate = need_exprstate;
1319  /* For safety, establish the callback before acquiring a refcount */
1320  ref->refctx = refctx;
1321  ref->dcc = NULL;
1323  ref->callback.arg = (void *) ref;
1325  /* Acquire refcount if there are constraints, and set up exported list */
1326  if (ref->tcache->domainData)
1327  {
1328  ref->dcc = ref->tcache->domainData;
1329  ref->dcc->dccRefCount++;
1330  if (ref->need_exprstate)
1332  ref->refctx);
1333  else
1334  ref->constraints = ref->dcc->constraints;
1335  }
1336  else
1337  ref->constraints = NIL;
1338 }
void MemoryContextRegisterResetCallback(MemoryContext context, MemoryContextCallback *cb)
Definition: mcxt.c:568
#define NIL
Definition: pg_list.h:68
DomainConstraintCache * dcc
Definition: typcache.h:172
MemoryContext refctx
Definition: typcache.h:167
MemoryContextCallback callback
Definition: typcache.h:173
TypeCacheEntry * tcache
Definition: typcache.h:168
MemoryContextCallbackFunction func
Definition: palloc.h:49
static List * prep_domain_constraints(List *constraints, MemoryContext execctx)
Definition: typcache.c:1275
static void dccref_deletion_callback(void *arg)
Definition: typcache.c:1254

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()

◆ lookup_rowtype_tupdesc_copy()

TupleDesc lookup_rowtype_tupdesc_copy ( Oid  type_id,
int32  typmod 
)

Definition at line 1867 of file typcache.c.

1868 {
1869  TupleDesc tmp;
1870 
1871  tmp = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
1872  return CreateTupleDescCopyConstr(tmp);
1873 }
TupleDesc CreateTupleDescCopyConstr(TupleDesc tupdesc)
Definition: tupdesc.c:173

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 1889 of file typcache.c.

1890 {
1891  TupleDesc tupDesc;
1892 
1893  if (type_id != RECORDOID)
1894  {
1895  /*
1896  * Check for domain or named composite type. We might as well load
1897  * whichever data is needed.
1898  */
1899  TypeCacheEntry *typentry;
1900 
1901  typentry = lookup_type_cache(type_id,
1904  if (typentry->typtype == TYPTYPE_DOMAIN)
1906  typentry->domainBaseTypmod,
1907  noError);
1908  if (typentry->tupDesc == NULL && !noError)
1909  ereport(ERROR,
1910  (errcode(ERRCODE_WRONG_OBJECT_TYPE),
1911  errmsg("type %s is not composite",
1912  format_type_be(type_id))));
1913  tupDesc = typentry->tupDesc;
1914  }
1915  else
1916  tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
1917  if (tupDesc != NULL)
1918  PinTupleDesc(tupDesc);
1919  return tupDesc;
1920 }
int32 domainBaseTypmod
Definition: typcache.h:115
char typtype
Definition: typcache.h:43
Oid domainBaseType
Definition: typcache.h:114
TupleDesc lookup_rowtype_tupdesc_noerror(Oid type_id, int32 typmod, bool noError)
Definition: typcache.c:1850
#define TYPECACHE_DOMAIN_BASE_INFO
Definition: typcache.h:149

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 1850 of file typcache.c.

1851 {
1852  TupleDesc tupDesc;
1853 
1854  tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
1855  if (tupDesc != NULL)
1856  PinTupleDesc(tupDesc);
1857  return tupDesc;
1858 }

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 346 of file typcache.c.

347 {
348  TypeCacheEntry *typentry;
349  bool found;
350 
351  if (TypeCacheHash == NULL)
352  {
353  /* First time through: initialize the hash table */
354  HASHCTL ctl;
355 
356  ctl.keysize = sizeof(Oid);
357  ctl.entrysize = sizeof(TypeCacheEntry);
358  TypeCacheHash = hash_create("Type information cache", 64,
359  &ctl, HASH_ELEM | HASH_BLOBS);
360 
361  /* Also set up callbacks for SI invalidations */
366 
367  /* Also make sure CacheMemoryContext exists */
368  if (!CacheMemoryContext)
370  }
371 
372  /* Try to look up an existing entry */
374  &type_id,
375  HASH_FIND, NULL);
376  if (typentry == NULL)
377  {
378  /*
379  * If we didn't find one, we want to make one. But first look up the
380  * pg_type row, just to make sure we don't make a cache entry for an
381  * invalid type OID. If the type OID is not valid, present a
382  * user-facing error, since some code paths such as domain_in() allow
383  * this function to be reached with a user-supplied OID.
384  */
385  HeapTuple tp;
386  Form_pg_type typtup;
387 
388  tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
389  if (!HeapTupleIsValid(tp))
390  ereport(ERROR,
391  (errcode(ERRCODE_UNDEFINED_OBJECT),
392  errmsg("type with OID %u does not exist", type_id)));
393  typtup = (Form_pg_type) GETSTRUCT(tp);
394  if (!typtup->typisdefined)
395  ereport(ERROR,
396  (errcode(ERRCODE_UNDEFINED_OBJECT),
397  errmsg("type \"%s\" is only a shell",
398  NameStr(typtup->typname))));
399 
400  /* Now make the typcache entry */
402  &type_id,
403  HASH_ENTER, &found);
404  Assert(!found); /* it wasn't there a moment ago */
405 
406  MemSet(typentry, 0, sizeof(TypeCacheEntry));
407 
408  /* These fields can never change, by definition */
409  typentry->type_id = type_id;
410  typentry->type_id_hash = GetSysCacheHashValue1(TYPEOID,
411  ObjectIdGetDatum(type_id));
412 
413  /* Keep this part in sync with the code below */
414  typentry->typlen = typtup->typlen;
415  typentry->typbyval = typtup->typbyval;
416  typentry->typalign = typtup->typalign;
417  typentry->typstorage = typtup->typstorage;
418  typentry->typtype = typtup->typtype;
419  typentry->typrelid = typtup->typrelid;
420  typentry->typsubscript = typtup->typsubscript;
421  typentry->typelem = typtup->typelem;
422  typentry->typcollation = typtup->typcollation;
423  typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
424 
425  /* If it's a domain, immediately thread it into the domain cache list */
426  if (typentry->typtype == TYPTYPE_DOMAIN)
427  {
428  typentry->nextDomain = firstDomainTypeEntry;
429  firstDomainTypeEntry = typentry;
430  }
431 
432  ReleaseSysCache(tp);
433  }
434  else if (!(typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
435  {
436  /*
437  * We have an entry, but its pg_type row got changed, so reload the
438  * data obtained directly from pg_type.
439  */
440  HeapTuple tp;
441  Form_pg_type typtup;
442 
443  tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
444  if (!HeapTupleIsValid(tp))
445  ereport(ERROR,
446  (errcode(ERRCODE_UNDEFINED_OBJECT),
447  errmsg("type with OID %u does not exist", type_id)));
448  typtup = (Form_pg_type) GETSTRUCT(tp);
449  if (!typtup->typisdefined)
450  ereport(ERROR,
451  (errcode(ERRCODE_UNDEFINED_OBJECT),
452  errmsg("type \"%s\" is only a shell",
453  NameStr(typtup->typname))));
454 
455  /*
456  * Keep this part in sync with the code above. Many of these fields
457  * shouldn't ever change, particularly typtype, but copy 'em anyway.
458  */
459  typentry->typlen = typtup->typlen;
460  typentry->typbyval = typtup->typbyval;
461  typentry->typalign = typtup->typalign;
462  typentry->typstorage = typtup->typstorage;
463  typentry->typtype = typtup->typtype;
464  typentry->typrelid = typtup->typrelid;
465  typentry->typsubscript = typtup->typsubscript;
466  typentry->typelem = typtup->typelem;
467  typentry->typcollation = typtup->typcollation;
468  typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
469 
470  ReleaseSysCache(tp);
471  }
472 
473  /*
474  * Look up opclasses if we haven't already and any dependent info is
475  * requested.
476  */
481  !(typentry->flags & TCFLAGS_CHECKED_BTREE_OPCLASS))
482  {
483  Oid opclass;
484 
485  opclass = GetDefaultOpClass(type_id, BTREE_AM_OID);
486  if (OidIsValid(opclass))
487  {
488  typentry->btree_opf = get_opclass_family(opclass);
489  typentry->btree_opintype = get_opclass_input_type(opclass);
490  }
491  else
492  {
493  typentry->btree_opf = typentry->btree_opintype = InvalidOid;
494  }
495 
496  /*
497  * Reset information derived from btree opclass. Note in particular
498  * that we'll redetermine the eq_opr even if we previously found one;
499  * this matters in case a btree opclass has been added to a type that
500  * previously had only a hash opclass.
501  */
502  typentry->flags &= ~(TCFLAGS_CHECKED_EQ_OPR |
507  }
508 
509  /*
510  * If we need to look up equality operator, and there's no btree opclass,
511  * force lookup of hash opclass.
512  */
513  if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
514  !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR) &&
515  typentry->btree_opf == InvalidOid)
516  flags |= TYPECACHE_HASH_OPFAMILY;
517 
522  !(typentry->flags & TCFLAGS_CHECKED_HASH_OPCLASS))
523  {
524  Oid opclass;
525 
526  opclass = GetDefaultOpClass(type_id, HASH_AM_OID);
527  if (OidIsValid(opclass))
528  {
529  typentry->hash_opf = get_opclass_family(opclass);
530  typentry->hash_opintype = get_opclass_input_type(opclass);
531  }
532  else
533  {
534  typentry->hash_opf = typentry->hash_opintype = InvalidOid;
535  }
536 
537  /*
538  * Reset information derived from hash opclass. We do *not* reset the
539  * eq_opr; if we already found one from the btree opclass, that
540  * decision is still good.
541  */
542  typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
544  typentry->flags |= TCFLAGS_CHECKED_HASH_OPCLASS;
545  }
546 
547  /*
548  * Look for requested operators and functions, if we haven't already.
549  */
550  if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
551  !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR))
552  {
553  Oid eq_opr = InvalidOid;
554 
555  if (typentry->btree_opf != InvalidOid)
556  eq_opr = get_opfamily_member(typentry->btree_opf,
557  typentry->btree_opintype,
558  typentry->btree_opintype,
560  if (eq_opr == InvalidOid &&
561  typentry->hash_opf != InvalidOid)
562  eq_opr = get_opfamily_member(typentry->hash_opf,
563  typentry->hash_opintype,
564  typentry->hash_opintype,
566 
567  /*
568  * If the proposed equality operator is array_eq or record_eq, check
569  * to see if the element type or column types support equality. If
570  * not, array_eq or record_eq would fail at runtime, so we don't want
571  * to report that the type has equality. (We can omit similar
572  * checking for ranges and multiranges because ranges can't be created
573  * in the first place unless their subtypes support equality.)
574  */
575  if (eq_opr == ARRAY_EQ_OP &&
576  !array_element_has_equality(typentry))
577  eq_opr = InvalidOid;
578  else if (eq_opr == RECORD_EQ_OP &&
579  !record_fields_have_equality(typentry))
580  eq_opr = InvalidOid;
581 
582  /* Force update of eq_opr_finfo only if we're changing state */
583  if (typentry->eq_opr != eq_opr)
584  typentry->eq_opr_finfo.fn_oid = InvalidOid;
585 
586  typentry->eq_opr = eq_opr;
587 
588  /*
589  * Reset info about hash functions whenever we pick up new info about
590  * equality operator. This is so we can ensure that the hash
591  * functions match the operator.
592  */
593  typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
595  typentry->flags |= TCFLAGS_CHECKED_EQ_OPR;
596  }
597  if ((flags & TYPECACHE_LT_OPR) &&
598  !(typentry->flags & TCFLAGS_CHECKED_LT_OPR))
599  {
600  Oid lt_opr = InvalidOid;
601 
602  if (typentry->btree_opf != InvalidOid)
603  lt_opr = get_opfamily_member(typentry->btree_opf,
604  typentry->btree_opintype,
605  typentry->btree_opintype,
607 
608  /*
609  * As above, make sure array_cmp or record_cmp will succeed; but again
610  * we need no special check for ranges or multiranges.
611  */
612  if (lt_opr == ARRAY_LT_OP &&
613  !array_element_has_compare(typentry))
614  lt_opr = InvalidOid;
615  else if (lt_opr == RECORD_LT_OP &&
616  !record_fields_have_compare(typentry))
617  lt_opr = InvalidOid;
618 
619  typentry->lt_opr = lt_opr;
620  typentry->flags |= TCFLAGS_CHECKED_LT_OPR;
621  }
622  if ((flags & TYPECACHE_GT_OPR) &&
623  !(typentry->flags & TCFLAGS_CHECKED_GT_OPR))
624  {
625  Oid gt_opr = InvalidOid;
626 
627  if (typentry->btree_opf != InvalidOid)
628  gt_opr = get_opfamily_member(typentry->btree_opf,
629  typentry->btree_opintype,
630  typentry->btree_opintype,
632 
633  /*
634  * As above, make sure array_cmp or record_cmp will succeed; but again
635  * we need no special check for ranges or multiranges.
636  */
637  if (gt_opr == ARRAY_GT_OP &&
638  !array_element_has_compare(typentry))
639  gt_opr = InvalidOid;
640  else if (gt_opr == RECORD_GT_OP &&
641  !record_fields_have_compare(typentry))
642  gt_opr = InvalidOid;
643 
644  typentry->gt_opr = gt_opr;
645  typentry->flags |= TCFLAGS_CHECKED_GT_OPR;
646  }
647  if ((flags & (TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO)) &&
648  !(typentry->flags & TCFLAGS_CHECKED_CMP_PROC))
649  {
650  Oid cmp_proc = InvalidOid;
651 
652  if (typentry->btree_opf != InvalidOid)
653  cmp_proc = get_opfamily_proc(typentry->btree_opf,
654  typentry->btree_opintype,
655  typentry->btree_opintype,
656  BTORDER_PROC);
657 
658  /*
659  * As above, make sure array_cmp or record_cmp will succeed; but again
660  * we need no special check for ranges or multiranges.
661  */
662  if (cmp_proc == F_BTARRAYCMP &&
663  !array_element_has_compare(typentry))
664  cmp_proc = InvalidOid;
665  else if (cmp_proc == F_BTRECORDCMP &&
666  !record_fields_have_compare(typentry))
667  cmp_proc = InvalidOid;
668 
669  /* Force update of cmp_proc_finfo only if we're changing state */
670  if (typentry->cmp_proc != cmp_proc)
671  typentry->cmp_proc_finfo.fn_oid = InvalidOid;
672 
673  typentry->cmp_proc = cmp_proc;
674  typentry->flags |= TCFLAGS_CHECKED_CMP_PROC;
675  }
677  !(typentry->flags & TCFLAGS_CHECKED_HASH_PROC))
678  {
679  Oid hash_proc = InvalidOid;
680 
681  /*
682  * We insist that the eq_opr, if one has been determined, match the
683  * hash opclass; else report there is no hash function.
684  */
685  if (typentry->hash_opf != InvalidOid &&
686  (!OidIsValid(typentry->eq_opr) ||
687  typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
688  typentry->hash_opintype,
689  typentry->hash_opintype,
691  hash_proc = get_opfamily_proc(typentry->hash_opf,
692  typentry->hash_opintype,
693  typentry->hash_opintype,
695 
696  /*
697  * As above, make sure hash_array, hash_record, or hash_range will
698  * succeed.
699  */
700  if (hash_proc == F_HASH_ARRAY &&
701  !array_element_has_hashing(typentry))
702  hash_proc = InvalidOid;
703  else if (hash_proc == F_HASH_RECORD &&
704  !record_fields_have_hashing(typentry))
705  hash_proc = InvalidOid;
706  else if (hash_proc == F_HASH_RANGE &&
707  !range_element_has_hashing(typentry))
708  hash_proc = InvalidOid;
709 
710  /*
711  * Likewise for hash_multirange.
712  */
713  if (hash_proc == F_HASH_MULTIRANGE &&
715  hash_proc = InvalidOid;
716 
717  /* Force update of hash_proc_finfo only if we're changing state */
718  if (typentry->hash_proc != hash_proc)
719  typentry->hash_proc_finfo.fn_oid = InvalidOid;
720 
721  typentry->hash_proc = hash_proc;
722  typentry->flags |= TCFLAGS_CHECKED_HASH_PROC;
723  }
724  if ((flags & (TYPECACHE_HASH_EXTENDED_PROC |
727  {
728  Oid hash_extended_proc = InvalidOid;
729 
730  /*
731  * We insist that the eq_opr, if one has been determined, match the
732  * hash opclass; else report there is no hash function.
733  */
734  if (typentry->hash_opf != InvalidOid &&
735  (!OidIsValid(typentry->eq_opr) ||
736  typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
737  typentry->hash_opintype,
738  typentry->hash_opintype,
740  hash_extended_proc = get_opfamily_proc(typentry->hash_opf,
741  typentry->hash_opintype,
742  typentry->hash_opintype,
744 
745  /*
746  * As above, make sure hash_array_extended, hash_record_extended, or
747  * hash_range_extended will succeed.
748  */
749  if (hash_extended_proc == F_HASH_ARRAY_EXTENDED &&
751  hash_extended_proc = InvalidOid;
752  else if (hash_extended_proc == F_HASH_RECORD_EXTENDED &&
754  hash_extended_proc = InvalidOid;
755  else if (hash_extended_proc == F_HASH_RANGE_EXTENDED &&
757  hash_extended_proc = InvalidOid;
758 
759  /*
760  * Likewise for hash_multirange_extended.
761  */
762  if (hash_extended_proc == F_HASH_MULTIRANGE_EXTENDED &&
764  hash_extended_proc = InvalidOid;
765 
766  /* Force update of proc finfo only if we're changing state */
767  if (typentry->hash_extended_proc != hash_extended_proc)
769 
770  typentry->hash_extended_proc = hash_extended_proc;
772  }
773 
774  /*
775  * Set up fmgr lookup info as requested
776  *
777  * Note: we tell fmgr the finfo structures live in CacheMemoryContext,
778  * which is not quite right (they're really in the hash table's private
779  * memory context) but this will do for our purposes.
780  *
781  * Note: the code above avoids invalidating the finfo structs unless the
782  * referenced operator/function OID actually changes. This is to prevent
783  * unnecessary leakage of any subsidiary data attached to an finfo, since
784  * that would cause session-lifespan memory leaks.
785  */
786  if ((flags & TYPECACHE_EQ_OPR_FINFO) &&
787  typentry->eq_opr_finfo.fn_oid == InvalidOid &&
788  typentry->eq_opr != InvalidOid)
789  {
790  Oid eq_opr_func;
791 
792  eq_opr_func = get_opcode(typentry->eq_opr);
793  if (eq_opr_func != InvalidOid)
794  fmgr_info_cxt(eq_opr_func, &typentry->eq_opr_finfo,
796  }
797  if ((flags & TYPECACHE_CMP_PROC_FINFO) &&
798  typentry->cmp_proc_finfo.fn_oid == InvalidOid &&
799  typentry->cmp_proc != InvalidOid)
800  {
801  fmgr_info_cxt(typentry->cmp_proc, &typentry->cmp_proc_finfo,
803  }
804  if ((flags & TYPECACHE_HASH_PROC_FINFO) &&
805  typentry->hash_proc_finfo.fn_oid == InvalidOid &&
806  typentry->hash_proc != InvalidOid)
807  {
808  fmgr_info_cxt(typentry->hash_proc, &typentry->hash_proc_finfo,
810  }
811  if ((flags & TYPECACHE_HASH_EXTENDED_PROC_FINFO) &&
813  typentry->hash_extended_proc != InvalidOid)
814  {
816  &typentry->hash_extended_proc_finfo,
818  }
819 
820  /*
821  * If it's a composite type (row type), get tupdesc if requested
822  */
823  if ((flags & TYPECACHE_TUPDESC) &&
824  typentry->tupDesc == NULL &&
825  typentry->typtype == TYPTYPE_COMPOSITE)
826  {
827  load_typcache_tupdesc(typentry);
828  }
829 
830  /*
831  * If requested, get information about a range type
832  *
833  * This includes making sure that the basic info about the range element
834  * type is up-to-date.
835  */
836  if ((flags & TYPECACHE_RANGE_INFO) &&
837  typentry->typtype == TYPTYPE_RANGE)
838  {
839  if (typentry->rngelemtype == NULL)
840  load_rangetype_info(typentry);
841  else if (!(typentry->rngelemtype->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
842  (void) lookup_type_cache(typentry->rngelemtype->type_id, 0);
843  }
844 
845  /*
846  * If requested, get information about a multirange type
847  */
848  if ((flags & TYPECACHE_MULTIRANGE_INFO) &&
849  typentry->rngtype == NULL &&
850  typentry->typtype == TYPTYPE_MULTIRANGE)
851  {
852  load_multirangetype_info(typentry);
853  }
854 
855  /*
856  * If requested, get information about a domain type
857  */
858  if ((flags & TYPECACHE_DOMAIN_BASE_INFO) &&
859  typentry->domainBaseType == InvalidOid &&
860  typentry->typtype == TYPTYPE_DOMAIN)
861  {
862  typentry->domainBaseTypmod = -1;
863  typentry->domainBaseType =
864  getBaseTypeAndTypmod(type_id, &typentry->domainBaseTypmod);
865  }
866  if ((flags & TYPECACHE_DOMAIN_CONSTR_INFO) &&
867  (typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
868  typentry->typtype == TYPTYPE_DOMAIN)
869  {
870  load_domaintype_info(typentry);
871  }
872 
873  return typentry;
874 }
#define NameStr(name)
Definition: c.h:746
#define MemSet(start, val, len)
Definition: c.h:1020
#define OidIsValid(objectId)
Definition: c.h:775
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition: fmgr.c:137
#define HASHSTANDARD_PROC
Definition: hash.h:355
#define HASHEXTENDED_PROC
Definition: hash.h:356
#define HASH_BLOBS
Definition: hsearch.h:97
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
Oid GetDefaultOpClass(Oid type_id, Oid am_id)
Definition: indexcmds.c:2300
void CacheRegisterRelcacheCallback(RelcacheCallbackFunction func, Datum arg)
Definition: inval.c:1558
void CacheRegisterSyscacheCallback(int cacheid, SyscacheCallbackFunction func, Datum arg)
Definition: inval.c:1516
Oid get_opclass_input_type(Oid opclass)
Definition: lsyscache.c:1212
Oid get_opclass_family(Oid opclass)
Definition: lsyscache.c:1190
Oid get_opfamily_proc(Oid opfamily, Oid lefttype, Oid righttype, int16 procnum)
Definition: lsyscache.c:796
RegProcedure get_opcode(Oid opno)
Definition: lsyscache.c:1285
Oid get_opfamily_member(Oid opfamily, Oid lefttype, Oid righttype, int16 strategy)
Definition: lsyscache.c:166
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2538
#define BTORDER_PROC
Definition: nbtree.h:707
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
uintptr_t Datum
Definition: postgres.h:64
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
#define BTGreaterStrategyNumber
Definition: stratnum.h:33
#define HTEqualStrategyNumber
Definition: stratnum.h:41
#define BTLessStrategyNumber
Definition: stratnum.h:29
#define BTEqualStrategyNumber
Definition: stratnum.h:31
Oid fn_oid
Definition: fmgr.h:59
uint32 type_id_hash
Definition: typcache.h:36
FmgrInfo hash_proc_finfo
Definition: typcache.h:77
Oid hash_extended_proc
Definition: typcache.h:66
Oid typsubscript
Definition: typcache.h:45
FmgrInfo cmp_proc_finfo
Definition: typcache.h:76
char typalign
Definition: typcache.h:41
struct TypeCacheEntry * rngelemtype
Definition: typcache.h:98
FmgrInfo hash_extended_proc_finfo
Definition: typcache.h:78
struct TypeCacheEntry * rngtype
Definition: typcache.h:108
FmgrInfo eq_opr_finfo
Definition: typcache.h:75
Oid btree_opintype
Definition: typcache.h:58
struct TypeCacheEntry * nextDomain
Definition: typcache.h:133
bool typbyval
Definition: typcache.h:40
int16 typlen
Definition: typcache.h:39
Oid hash_opintype
Definition: typcache.h:60
Oid typcollation
Definition: typcache.h:47
char typstorage
Definition: typcache.h:42
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218
#define GetSysCacheHashValue1(cacheId, key1)
Definition: syscache.h:113
#define TCFLAGS_CHECKED_BTREE_OPCLASS
Definition: typcache.c:85
#define TCFLAGS_CHECKED_HASH_OPCLASS
Definition: typcache.c:86
static bool range_element_has_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1626
static bool record_fields_have_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1505
static bool record_fields_have_extended_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1513
#define TCFLAGS_CHECKED_GT_OPR
Definition: typcache.c:89
static bool multirange_element_has_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1666
static bool record_fields_have_equality(TypeCacheEntry *typentry)
Definition: typcache.c:1489
#define TCFLAGS_CHECKED_LT_OPR
Definition: typcache.c:88
#define TCFLAGS_CHECKED_HASH_PROC
Definition: typcache.c:91
static bool array_element_has_extended_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1451
static bool array_element_has_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1443
static void load_multirangetype_info(TypeCacheEntry *typentry)
Definition: typcache.c:972
#define TCFLAGS_CHECKED_CMP_PROC
Definition: typcache.c:90
static bool multirange_element_has_extended_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1674
static bool array_element_has_equality(TypeCacheEntry *typentry)
Definition: typcache.c:1427
static void load_rangetype_info(TypeCacheEntry *typentry)
Definition: typcache.c:914
static bool range_element_has_extended_hashing(TypeCacheEntry *typentry)
Definition: typcache.c:1634
static TypeCacheEntry * firstDomainTypeEntry
Definition: typcache.c:81
#define TCFLAGS_CHECKED_HASH_EXTENDED_PROC
Definition: typcache.c:92
static void TypeCacheTypCallback(Datum arg, int cacheid, uint32 hashvalue)
Definition: typcache.c:2355
static void TypeCacheConstrCallback(Datum arg, int cacheid, uint32 hashvalue)
Definition: typcache.c:2424
static void TypeCacheOpcCallback(Datum arg, int cacheid, uint32 hashvalue)
Definition: typcache.c:2395
static void load_domaintype_info(TypeCacheEntry *typentry)
Definition: typcache.c:994
static void TypeCacheRelCallback(Datum arg, Oid relid)
Definition: typcache.c:2290
static bool array_element_has_compare(TypeCacheEntry *typentry)
Definition: typcache.c:1435
#define TCFLAGS_HAVE_PG_TYPE_DATA
Definition: typcache.c:84
#define TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS
Definition: typcache.c:103
static HTAB * TypeCacheHash
Definition: typcache.c:78
static bool record_fields_have_compare(TypeCacheEntry *typentry)
Definition: typcache.c:1497
#define TCFLAGS_CHECKED_EQ_OPR
Definition: typcache.c:87
static void load_typcache_tupdesc(TypeCacheEntry *typentry)
Definition: typcache.c:880
#define TYPECACHE_HASH_PROC_FINFO
Definition: typcache.h:144
#define TYPECACHE_EQ_OPR
Definition: typcache.h:137
#define TYPECACHE_HASH_OPFAMILY
Definition: typcache.h:147
#define TYPECACHE_MULTIRANGE_INFO
Definition: typcache.h:153
#define TYPECACHE_EQ_OPR_FINFO
Definition: typcache.h:142
#define TYPECACHE_HASH_EXTENDED_PROC
Definition: typcache.h:151
#define TYPECACHE_BTREE_OPFAMILY
Definition: typcache.h:146
#define TYPECACHE_RANGE_INFO
Definition: typcache.h:148
#define TYPECACHE_GT_OPR
Definition: typcache.h:139
#define TYPECACHE_CMP_PROC
Definition: typcache.h:140
struct TypeCacheEntry TypeCacheEntry
#define TYPECACHE_LT_OPR
Definition: typcache.h:138
#define TYPECACHE_HASH_EXTENDED_PROC_FINFO
Definition: typcache.h:152
#define TYPECACHE_CMP_PROC_FINFO
Definition: typcache.h:143
#define TYPECACHE_HASH_PROC
Definition: typcache.h:141

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_opclass_family(), get_opclass_input_type(), get_opcode(), get_opfamily_member(), get_opfamily_proc(), getBaseTypeAndTypmod(), GetDefaultOpClass(), GETSTRUCT, GetSysCacheHashValue1, TypeCacheEntry::gt_opr, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_extended_proc_finfo, HASH_FIND, TypeCacheEntry::hash_opf, TypeCacheEntry::hash_opintype, TypeCacheEntry::hash_proc, TypeCacheEntry::hash_proc_finfo, hash_search(), HASHEXTENDED_PROC, HASHSTANDARD_PROC, HeapTupleIsValid, HTEqualStrategyNumber, InvalidOid, load_domaintype_info(), load_multirangetype_info(), load_rangetype_info(), load_typcache_tupdesc(), TypeCacheEntry::lt_opr, 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(), 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, 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_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_memoizable(), contain_leaked_vars_walker(), CreateStatistics(), dependency_degree(), domain_state_setup(), DomainHasConstraints(), enum_cmp_internal(), ExecInitExprRec(), find_simplified_clause(), foreign_expr_walker(), get_cached_rowtype(), 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 2207 of file typcache.c.

2208 {
2209  MemoryContext old_context;
2210  dshash_table *record_table;
2211  dshash_table *typmod_table;
2212 
2214 
2215  /* We can't already be attached to a shared registry. */
2216  Assert(CurrentSession != NULL);
2217  Assert(CurrentSession->segment != NULL);
2218  Assert(CurrentSession->area != NULL);
2222 
2223  /*
2224  * We can't already have typmods in our local cache, because they'd clash
2225  * with those imported by SharedRecordTypmodRegistryInit. This should be
2226  * a freshly started parallel worker. If we ever support worker
2227  * recycling, a worker would need to zap its local cache in between
2228  * servicing different queries, in order to be able to call this and
2229  * synchronize typmods with a new leader; but that's problematic because
2230  * we can't be very sure that record-typmod-related state hasn't escaped
2231  * to anywhere else in the process.
2232  */
2233  Assert(NextRecordTypmod == 0);
2234 
2235  old_context = MemoryContextSwitchTo(TopMemoryContext);
2236 
2237  /* Attach to the two hash tables. */
2238  record_table = dshash_attach(CurrentSession->area,
2240  registry->record_table_handle,
2241  CurrentSession->area);
2242  typmod_table = dshash_attach(CurrentSession->area,
2244  registry->typmod_table_handle,
2245  NULL);
2246 
2247  MemoryContextSwitchTo(old_context);
2248 
2249  /*
2250  * Set up detach hook to run at worker exit. Currently this is the same
2251  * as the leader's detach hook, but in future they might need to be
2252  * different.
2253  */
2256  PointerGetDatum(registry));
2257 
2258  /*
2259  * Set up the session state that will tell assign_record_type_typmod and
2260  * lookup_rowtype_tupdesc_internal about the shared registry.
2261  */
2263  CurrentSession->shared_record_table = record_table;
2264  CurrentSession->shared_typmod_table = typmod_table;
2265 }
dshash_table * dshash_attach(dsa_area *area, const dshash_parameters *params, dshash_table_handle handle, void *arg)
Definition: dshash.c:270
void on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
Definition: dsm.c:1132
#define IsParallelWorker()
Definition: parallel.h:60
MemoryContext TopMemoryContext
Definition: mcxt.c:149
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
Session * CurrentSession
Definition: session.c:48
dsm_segment * segment
Definition: session.h:27
dshash_table * shared_record_table
Definition: session.h:32
struct SharedRecordTypmodRegistry * shared_typmod_registry
Definition: session.h:31
dsa_area * area
Definition: session.h:28
dshash_table * shared_typmod_table
Definition: session.h:33
dshash_table_handle typmod_table_handle
Definition: typcache.c:171
dshash_table_handle record_table_handle
Definition: typcache.c:169
static const dshash_parameters srtr_typmod_table_params
Definition: typcache.c:266
static void shared_record_typmod_registry_detach(dsm_segment *segment, Datum datum)
Definition: typcache.c:2868
static const dshash_parameters srtr_record_table_params
Definition: typcache.c:256

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 2086 of file typcache.c.

2087 {
2088  return sizeof(SharedRecordTypmodRegistry);
2089 }
struct SharedRecordTypmodRegistry SharedRecordTypmodRegistry
Definition: typcache.h:176

Referenced by GetSessionDsmHandle().

◆ SharedRecordTypmodRegistryInit()

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

Definition at line 2108 of file typcache.c.

2111 {
2112  MemoryContext old_context;
2113  dshash_table *record_table;
2114  dshash_table *typmod_table;
2115  int32 typmod;
2116 
2118 
2119  /* We can't already be attached to a shared registry. */
2123 
2124  old_context = MemoryContextSwitchTo(TopMemoryContext);
2125 
2126  /* Create the hash table of tuple descriptors indexed by themselves. */
2127  record_table = dshash_create(area, &srtr_record_table_params, area);
2128 
2129  /* Create the hash table of tuple descriptors indexed by typmod. */
2130  typmod_table = dshash_create(area, &srtr_typmod_table_params, NULL);
2131 
2132  MemoryContextSwitchTo(old_context);
2133 
2134  /* Initialize the SharedRecordTypmodRegistry. */
2135  registry->record_table_handle = dshash_get_hash_table_handle(record_table);
2136  registry->typmod_table_handle = dshash_get_hash_table_handle(typmod_table);
2138 
2139  /*
2140  * Copy all entries from this backend's private registry into the shared
2141  * registry.
2142  */
2143  for (typmod = 0; typmod < NextRecordTypmod; ++typmod)
2144  {
2145  SharedTypmodTableEntry *typmod_table_entry;
2146  SharedRecordTableEntry *record_table_entry;
2147  SharedRecordTableKey record_table_key;
2148  dsa_pointer shared_dp;
2149  TupleDesc tupdesc;
2150  bool found;
2151 
2152  tupdesc = RecordCacheArray[typmod].tupdesc;
2153  if (tupdesc == NULL)
2154  continue;
2155 
2156  /* Copy the TupleDesc into shared memory. */
2157  shared_dp = share_tupledesc(area, tupdesc, typmod);
2158 
2159  /* Insert into the typmod table. */
2160  typmod_table_entry = dshash_find_or_insert(typmod_table,
2161  &tupdesc->tdtypmod,
2162  &found);
2163  if (found)
2164  elog(ERROR, "cannot create duplicate shared record typmod");
2165  typmod_table_entry->typmod = tupdesc->tdtypmod;
2166  typmod_table_entry->shared_tupdesc = shared_dp;
2167  dshash_release_lock(typmod_table, typmod_table_entry);
2168 
2169  /* Insert into the record table. */
2170  record_table_key.shared = false;
2171  record_table_key.u.local_tupdesc = tupdesc;
2172  record_table_entry = dshash_find_or_insert(record_table,
2173  &record_table_key,
2174  &found);
2175  if (!found)
2176  {
2177  record_table_entry->key.shared = true;
2178  record_table_entry->key.u.shared_tupdesc = shared_dp;
2179  }
2180  dshash_release_lock(record_table, record_table_entry);
2181  }
2182 
2183  /*
2184  * Set up the global state that will tell assign_record_type_typmod and
2185  * lookup_rowtype_tupdesc_internal about the shared registry.
2186  */
2187  CurrentSession->shared_record_table = record_table;
2188  CurrentSession->shared_typmod_table = typmod_table;
2190 
2191  /*
2192  * We install a detach hook in the leader, but only to handle cleanup on
2193  * failure during GetSessionDsmHandle(). Once GetSessionDsmHandle() pins
2194  * the memory, the leader process will use a shared registry until it
2195  * exits.
2196  */
2198 }
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:216
signed int int32
Definition: c.h:494
uint64 dsa_pointer
Definition: dsa.h:62
void dshash_release_lock(dshash_table *hash_table, void *entry)
Definition: dshash.c:558
dshash_table_handle dshash_get_hash_table_handle(dshash_table *hash_table)
Definition: dshash.c:367
void * dshash_find_or_insert(dshash_table *hash_table, const void *key, bool *found)
Definition: dshash.c:433
dshash_table * dshash_create(dsa_area *area, const dshash_parameters *params, void *arg)
Definition: dshash.c:206
SharedRecordTableKey key
Definition: typcache.c:198
TupleDesc local_tupdesc
Definition: typcache.c:186
union SharedRecordTableKey::@33 u
dsa_pointer shared_tupdesc
Definition: typcache.c:187
pg_atomic_uint32 next_typmod
Definition: typcache.c:173
dsa_pointer shared_tupdesc
Definition: typcache.c:208
static dsa_pointer share_tupledesc(dsa_area *area, TupleDesc tupdesc, uint32 typmod)
Definition: typcache.c:2735

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 1351 of file typcache.c.

1352 {
1353  TypeCacheEntry *typentry = ref->tcache;
1354 
1355  /* Make sure typcache entry's data is up to date */
1356  if ((typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
1357  typentry->typtype == TYPTYPE_DOMAIN)
1358  load_domaintype_info(typentry);
1359 
1360  /* Transfer to ref object if there's new info, adjusting refcounts */
1361  if (ref->dcc != typentry->domainData)
1362  {
1363  /* Paranoia --- be sure link is nulled before trying to release */
1364  DomainConstraintCache *dcc = ref->dcc;
1365 
1366  if (dcc)
1367  {
1368  /*
1369  * Note: we just leak the previous list of executable domain
1370  * constraints. Alternatively, we could keep those in a child
1371  * context of ref->refctx and free that context at this point.
1372  * However, in practice this code path will be taken so seldom
1373  * that the extra bookkeeping for a child context doesn't seem
1374  * worthwhile; we'll just allow a leak for the lifespan of refctx.
1375  */
1376  ref->constraints = NIL;
1377  ref->dcc = NULL;
1378  decr_dcc_refcount(dcc);
1379  }
1380  dcc = typentry->domainData;
1381  if (dcc)
1382  {
1383  ref->dcc = dcc;
1384  dcc->dccRefCount++;
1385  if (ref->need_exprstate)
1387  ref->refctx);
1388  else
1389  ref->constraints = dcc->constraints;
1390  }
1391  }
1392 }
static void decr_dcc_refcount(DomainConstraintCache *dcc)
Definition: typcache.c:1243

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().