1 /*------------------------------------------------------------------------- 2 * 3 * typcache.h 4 * Type cache definitions. 5 * 6 * The type cache exists to speed lookup of certain information about data 7 * types that is not directly available from a type's pg_type row. 8 * 9 * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group 10 * Portions Copyright (c) 1994, Regents of the University of California 11 * 12 * src/include/utils/typcache.h 13 * 14 *------------------------------------------------------------------------- 15 */ 16 #ifndef TYPCACHE_H 17 #define TYPCACHE_H 18 19 #include "access/tupdesc.h" 20 #include "fmgr.h" 21 #include "storage/dsm.h" 22 #include "utils/dsa.h" 23 24 25 /* DomainConstraintCache is an opaque struct known only within typcache.c */ 26 typedef struct DomainConstraintCache DomainConstraintCache; 27 28 /* TypeCacheEnumData is an opaque struct known only within typcache.c */ 29 struct TypeCacheEnumData; 30 31 typedef struct TypeCacheEntry 32 { 33 /* typeId is the hash lookup key and MUST BE FIRST */ 34 Oid type_id; /* OID of the data type */ 35 36 /* some subsidiary information copied from the pg_type row */ 37 int16 typlen; 38 bool typbyval; 39 char typalign; 40 char typstorage; 41 char typtype; 42 Oid typrelid; 43 Oid typelem; 44 45 /* 46 * Information obtained from opfamily entries 47 * 48 * These will be InvalidOid if no match could be found, or if the 49 * information hasn't yet been requested. Also note that for array and 50 * composite types, typcache.c checks that the contained types are 51 * comparable or hashable before allowing eq_opr etc to become set. 52 */ 53 Oid btree_opf; /* the default btree opclass' family */ 54 Oid btree_opintype; /* the default btree opclass' opcintype */ 55 Oid hash_opf; /* the default hash opclass' family */ 56 Oid hash_opintype; /* the default hash opclass' opcintype */ 57 Oid eq_opr; /* the equality operator */ 58 Oid lt_opr; /* the less-than operator */ 59 Oid gt_opr; /* the greater-than operator */ 60 Oid cmp_proc; /* the btree comparison function */ 61 Oid hash_proc; /* the hash calculation function */ 62 Oid hash_extended_proc; /* the extended hash calculation function */ 63 64 /* 65 * Pre-set-up fmgr call info for the equality operator, the btree 66 * comparison function, and the hash calculation function. These are kept 67 * in the type cache to avoid problems with memory leaks in repeated calls 68 * to functions such as array_eq, array_cmp, hash_array. There is not 69 * currently a need to maintain call info for the lt_opr or gt_opr. 70 */ 71 FmgrInfo eq_opr_finfo; 72 FmgrInfo cmp_proc_finfo; 73 FmgrInfo hash_proc_finfo; 74 FmgrInfo hash_extended_proc_finfo; 75 76 /* 77 * Tuple descriptor if it's a composite type (row type). NULL if not 78 * composite or information hasn't yet been requested. (NOTE: this is a 79 * reference-counted tupledesc.) 80 * 81 * To simplify caching dependent info, tupDesc_identifier is an identifier 82 * for this tupledesc that is unique for the life of the process, and 83 * changes anytime the tupledesc does. Zero if not yet determined. 84 */ 85 TupleDesc tupDesc; 86 uint64 tupDesc_identifier; 87 88 /* 89 * Fields computed when TYPECACHE_RANGE_INFO is requested. Zeroes if not 90 * a range type or information hasn't yet been requested. Note that 91 * rng_cmp_proc_finfo could be different from the element type's default 92 * btree comparison function. 93 */ 94 struct TypeCacheEntry *rngelemtype; /* range's element type */ 95 Oid rng_collation; /* collation for comparisons, if any */ 96 FmgrInfo rng_cmp_proc_finfo; /* comparison function */ 97 FmgrInfo rng_canonical_finfo; /* canonicalization function, if any */ 98 FmgrInfo rng_subdiff_finfo; /* difference function, if any */ 99 100 /* 101 * Domain's base type and typmod if it's a domain type. Zeroes if not 102 * domain, or if information hasn't been requested. 103 */ 104 Oid domainBaseType; 105 int32 domainBaseTypmod; 106 107 /* 108 * Domain constraint data if it's a domain type. NULL if not domain, or 109 * if domain has no constraints, or if information hasn't been requested. 110 */ 111 DomainConstraintCache *domainData; 112 113 /* Private data, for internal use of typcache.c only */ 114 int flags; /* flags about what we've computed */ 115 116 /* 117 * Private information about an enum type. NULL if not enum or 118 * information hasn't been requested. 119 */ 120 struct TypeCacheEnumData *enumData; 121 122 /* We also maintain a list of all known domain-type cache entries */ 123 struct TypeCacheEntry *nextDomain; 124 } TypeCacheEntry; 125 126 /* Bit flags to indicate which fields a given caller needs to have set */ 127 #define TYPECACHE_EQ_OPR 0x0001 128 #define TYPECACHE_LT_OPR 0x0002 129 #define TYPECACHE_GT_OPR 0x0004 130 #define TYPECACHE_CMP_PROC 0x0008 131 #define TYPECACHE_HASH_PROC 0x0010 132 #define TYPECACHE_EQ_OPR_FINFO 0x0020 133 #define TYPECACHE_CMP_PROC_FINFO 0x0040 134 #define TYPECACHE_HASH_PROC_FINFO 0x0080 135 #define TYPECACHE_TUPDESC 0x0100 136 #define TYPECACHE_BTREE_OPFAMILY 0x0200 137 #define TYPECACHE_HASH_OPFAMILY 0x0400 138 #define TYPECACHE_RANGE_INFO 0x0800 139 #define TYPECACHE_DOMAIN_BASE_INFO 0x1000 140 #define TYPECACHE_DOMAIN_CONSTR_INFO 0x2000 141 #define TYPECACHE_HASH_EXTENDED_PROC 0x4000 142 #define TYPECACHE_HASH_EXTENDED_PROC_FINFO 0x8000 143 144 /* This value will not equal any valid tupledesc identifier, nor 0 */ 145 #define INVALID_TUPLEDESC_IDENTIFIER ((uint64) 1) 146 147 /* 148 * Callers wishing to maintain a long-lived reference to a domain's constraint 149 * set must store it in one of these. Use InitDomainConstraintRef() and 150 * UpdateDomainConstraintRef() to manage it. Note: DomainConstraintState is 151 * considered an executable expression type, so it's defined in execnodes.h. 152 */ 153 typedef struct DomainConstraintRef 154 { 155 List *constraints; /* list of DomainConstraintState nodes */ 156 MemoryContext refctx; /* context holding DomainConstraintRef */ 157 TypeCacheEntry *tcache; /* typcache entry for domain type */ 158 bool need_exprstate; /* does caller need check_exprstate? */ 159 160 /* Management data --- treat these fields as private to typcache.c */ 161 DomainConstraintCache *dcc; /* current constraints, or NULL if none */ 162 MemoryContextCallback callback; /* used to release refcount when done */ 163 } DomainConstraintRef; 164 165 typedef struct SharedRecordTypmodRegistry SharedRecordTypmodRegistry; 166 167 extern TypeCacheEntry *lookup_type_cache(Oid type_id, int flags); 168 169 extern void InitDomainConstraintRef(Oid type_id, DomainConstraintRef *ref, 170 MemoryContext refctx, bool need_exprstate); 171 172 extern void UpdateDomainConstraintRef(DomainConstraintRef *ref); 173 174 extern bool DomainHasConstraints(Oid type_id); 175 176 extern TupleDesc lookup_rowtype_tupdesc(Oid type_id, int32 typmod); 177 178 extern TupleDesc lookup_rowtype_tupdesc_noerror(Oid type_id, int32 typmod, 179 bool noError); 180 181 extern TupleDesc lookup_rowtype_tupdesc_copy(Oid type_id, int32 typmod); 182 183 extern TupleDesc lookup_rowtype_tupdesc_domain(Oid type_id, int32 typmod, 184 bool noError); 185 186 extern void assign_record_type_typmod(TupleDesc tupDesc); 187 188 extern uint64 assign_record_type_identifier(Oid type_id, int32 typmod); 189 190 extern int compare_values_of_enum(TypeCacheEntry *tcache, Oid arg1, Oid arg2); 191 192 extern size_t SharedRecordTypmodRegistryEstimate(void); 193 194 extern void SharedRecordTypmodRegistryInit(SharedRecordTypmodRegistry *, 195 dsm_segment *segment, dsa_area *area); 196 197 extern void SharedRecordTypmodRegistryAttach(SharedRecordTypmodRegistry *); 198 199 #endif /* TYPCACHE_H */ 200