1 | /*------------------------------------------------------------------------- |
2 | * |
3 | * pg_type.h |
4 | * definition of the "type" system catalog (pg_type) |
5 | * |
6 | * |
7 | * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group |
8 | * Portions Copyright (c) 1994, Regents of the University of California |
9 | * |
10 | * src/include/catalog/pg_type.h |
11 | * |
12 | * NOTES |
13 | * The Catalog.pm module reads this file and derives schema |
14 | * information. |
15 | * |
16 | *------------------------------------------------------------------------- |
17 | */ |
18 | #ifndef PG_TYPE_H |
19 | #define PG_TYPE_H |
20 | |
21 | #include "catalog/genbki.h" |
22 | #include "catalog/pg_type_d.h" |
23 | |
24 | #include "catalog/objectaddress.h" |
25 | #include "nodes/nodes.h" |
26 | |
27 | /* ---------------- |
28 | * pg_type definition. cpp turns this into |
29 | * typedef struct FormData_pg_type |
30 | * |
31 | * Some of the values in a pg_type instance are copied into |
32 | * pg_attribute instances. Some parts of Postgres use the pg_type copy, |
33 | * while others use the pg_attribute copy, so they must match. |
34 | * See struct FormData_pg_attribute for details. |
35 | * ---------------- |
36 | */ |
37 | CATALOG(pg_type,1247,TypeRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(71,TypeRelation_Rowtype_Id) BKI_SCHEMA_MACRO |
38 | { |
39 | Oid oid; /* oid */ |
40 | |
41 | /* type name */ |
42 | NameData typname; |
43 | |
44 | /* OID of namespace containing this type */ |
45 | Oid typnamespace BKI_DEFAULT(PGNSP); |
46 | |
47 | /* type owner */ |
48 | Oid typowner BKI_DEFAULT(PGUID); |
49 | |
50 | /* |
51 | * For a fixed-size type, typlen is the number of bytes we use to |
52 | * represent a value of this type, e.g. 4 for an int4. But for a |
53 | * variable-length type, typlen is negative. We use -1 to indicate a |
54 | * "varlena" type (one that has a length word), -2 to indicate a |
55 | * null-terminated C string. |
56 | */ |
57 | int16 typlen BKI_ARRAY_DEFAULT(-1); |
58 | |
59 | /* |
60 | * typbyval determines whether internal Postgres routines pass a value of |
61 | * this type by value or by reference. typbyval had better be false if |
62 | * the length is not 1, 2, or 4 (or 8 on 8-byte-Datum machines). |
63 | * Variable-length types are always passed by reference. Note that |
64 | * typbyval can be false even if the length would allow pass-by-value; for |
65 | * example, type macaddr8 is pass-by-ref even when Datum is 8 bytes. |
66 | */ |
67 | bool typbyval BKI_ARRAY_DEFAULT(f); |
68 | |
69 | /* |
70 | * typtype is 'b' for a base type, 'c' for a composite type (e.g., a |
71 | * table's rowtype), 'd' for a domain, 'e' for an enum type, 'p' for a |
72 | * pseudo-type, or 'r' for a range type. (Use the TYPTYPE macros below.) |
73 | * |
74 | * If typtype is 'c', typrelid is the OID of the class' entry in pg_class. |
75 | */ |
76 | char typtype BKI_DEFAULT(b) BKI_ARRAY_DEFAULT(b); |
77 | |
78 | /* |
79 | * typcategory and typispreferred help the parser distinguish preferred |
80 | * and non-preferred coercions. The category can be any single ASCII |
81 | * character (but not \0). The categories used for built-in types are |
82 | * identified by the TYPCATEGORY macros below. |
83 | */ |
84 | |
85 | /* arbitrary type classification */ |
86 | char typcategory BKI_ARRAY_DEFAULT(A); |
87 | |
88 | /* is type "preferred" within its category? */ |
89 | bool typispreferred BKI_DEFAULT(f) BKI_ARRAY_DEFAULT(f); |
90 | |
91 | /* |
92 | * If typisdefined is false, the entry is only a placeholder (forward |
93 | * reference). We know the type's name and owner, but not yet anything |
94 | * else about it. |
95 | */ |
96 | bool typisdefined BKI_DEFAULT(t); |
97 | |
98 | /* delimiter for arrays of this type */ |
99 | char typdelim BKI_DEFAULT(','); |
100 | |
101 | /* associated pg_class OID if a composite type, else 0 */ |
102 | Oid typrelid BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_class); |
103 | |
104 | /* |
105 | * If typelem is not 0 then it identifies another row in pg_type. The |
106 | * current type can then be subscripted like an array yielding values of |
107 | * type typelem. A non-zero typelem does not guarantee this type to be a |
108 | * "real" array type; some ordinary fixed-length types can also be |
109 | * subscripted (e.g., name, point). Variable-length types can *not* be |
110 | * turned into pseudo-arrays like that. Hence, the way to determine |
111 | * whether a type is a "true" array type is if: |
112 | * |
113 | * typelem != 0 and typlen == -1. |
114 | */ |
115 | Oid typelem BKI_DEFAULT(0) BKI_LOOKUP(pg_type); |
116 | |
117 | /* |
118 | * If there is a "true" array type having this type as element type, |
119 | * typarray links to it. Zero if no associated "true" array type. |
120 | */ |
121 | Oid typarray BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_type); |
122 | |
123 | /* |
124 | * I/O conversion procedures for the datatype. |
125 | */ |
126 | |
127 | /* text format (required) */ |
128 | regproc typinput BKI_ARRAY_DEFAULT(array_in) BKI_LOOKUP(pg_proc); |
129 | regproc typoutput BKI_ARRAY_DEFAULT(array_out) BKI_LOOKUP(pg_proc); |
130 | |
131 | /* binary format (optional) */ |
132 | regproc typreceive BKI_ARRAY_DEFAULT(array_recv) BKI_LOOKUP(pg_proc); |
133 | regproc typsend BKI_ARRAY_DEFAULT(array_send) BKI_LOOKUP(pg_proc); |
134 | |
135 | /* |
136 | * I/O functions for optional type modifiers. |
137 | */ |
138 | regproc typmodin BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); |
139 | regproc typmodout BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); |
140 | |
141 | /* |
142 | * Custom ANALYZE procedure for the datatype (0 selects the default). |
143 | */ |
144 | regproc typanalyze BKI_DEFAULT(-) BKI_ARRAY_DEFAULT(array_typanalyze) BKI_LOOKUP(pg_proc); |
145 | |
146 | /* ---------------- |
147 | * typalign is the alignment required when storing a value of this |
148 | * type. It applies to storage on disk as well as most |
149 | * representations of the value inside Postgres. When multiple values |
150 | * are stored consecutively, such as in the representation of a |
151 | * complete row on disk, padding is inserted before a datum of this |
152 | * type so that it begins on the specified boundary. The alignment |
153 | * reference is the beginning of the first datum in the sequence. |
154 | * |
155 | * 'c' = CHAR alignment, ie no alignment needed. |
156 | * 's' = SHORT alignment (2 bytes on most machines). |
157 | * 'i' = INT alignment (4 bytes on most machines). |
158 | * 'd' = DOUBLE alignment (8 bytes on many machines, but by no means all). |
159 | * |
160 | * See include/access/tupmacs.h for the macros that compute these |
161 | * alignment requirements. Note also that we allow the nominal alignment |
162 | * to be violated when storing "packed" varlenas; the TOAST mechanism |
163 | * takes care of hiding that from most code. |
164 | * |
165 | * NOTE: for types used in system tables, it is critical that the |
166 | * size and alignment defined in pg_type agree with the way that the |
167 | * compiler will lay out the field in a struct representing a table row. |
168 | * ---------------- |
169 | */ |
170 | char typalign; |
171 | |
172 | /* ---------------- |
173 | * typstorage tells if the type is prepared for toasting and what |
174 | * the default strategy for attributes of this type should be. |
175 | * |
176 | * 'p' PLAIN type not prepared for toasting |
177 | * 'e' EXTERNAL external storage possible, don't try to compress |
178 | * 'x' EXTENDED try to compress and store external if required |
179 | * 'm' MAIN like 'x' but try to keep in main tuple |
180 | * ---------------- |
181 | */ |
182 | char typstorage BKI_DEFAULT(p) BKI_ARRAY_DEFAULT(x); |
183 | |
184 | /* |
185 | * This flag represents a "NOT NULL" constraint against this datatype. |
186 | * |
187 | * If true, the attnotnull column for a corresponding table column using |
188 | * this datatype will always enforce the NOT NULL constraint. |
189 | * |
190 | * Used primarily for domain types. |
191 | */ |
192 | bool typnotnull BKI_DEFAULT(f); |
193 | |
194 | /* |
195 | * Domains use typbasetype to show the base (or domain) type that the |
196 | * domain is based on. Zero if the type is not a domain. |
197 | */ |
198 | Oid typbasetype BKI_DEFAULT(0); |
199 | |
200 | /* |
201 | * Domains use typtypmod to record the typmod to be applied to their base |
202 | * type (-1 if base type does not use a typmod). -1 if this type is not a |
203 | * domain. |
204 | */ |
205 | int32 typtypmod BKI_DEFAULT(-1); |
206 | |
207 | /* |
208 | * typndims is the declared number of dimensions for an array domain type |
209 | * (i.e., typbasetype is an array type). Otherwise zero. |
210 | */ |
211 | int32 typndims BKI_DEFAULT(0); |
212 | |
213 | /* |
214 | * Collation: 0 if type cannot use collations, nonzero (typically |
215 | * DEFAULT_COLLATION_OID) for collatable base types, possibly some other |
216 | * OID for domains over collatable types |
217 | */ |
218 | Oid typcollation BKI_DEFAULT(0) BKI_LOOKUP(pg_collation); |
219 | |
220 | #ifdef CATALOG_VARLEN /* variable-length fields start here */ |
221 | |
222 | /* |
223 | * If typdefaultbin is not NULL, it is the nodeToString representation of |
224 | * a default expression for the type. Currently this is only used for |
225 | * domains. |
226 | */ |
227 | pg_node_tree typdefaultbin BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_); |
228 | |
229 | /* |
230 | * typdefault is NULL if the type has no associated default value. If |
231 | * typdefaultbin is not NULL, typdefault must contain a human-readable |
232 | * version of the default expression represented by typdefaultbin. If |
233 | * typdefaultbin is NULL and typdefault is not, then typdefault is the |
234 | * external representation of the type's default value, which may be fed |
235 | * to the type's input converter to produce a constant. |
236 | */ |
237 | text typdefault BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_); |
238 | |
239 | /* |
240 | * Access permissions |
241 | */ |
242 | aclitem typacl[1] BKI_DEFAULT(_null_); |
243 | #endif |
244 | } FormData_pg_type; |
245 | |
246 | /* ---------------- |
247 | * Form_pg_type corresponds to a pointer to a row with |
248 | * the format of pg_type relation. |
249 | * ---------------- |
250 | */ |
251 | typedef FormData_pg_type *Form_pg_type; |
252 | |
253 | #ifdef EXPOSE_TO_CLIENT_CODE |
254 | |
255 | /* |
256 | * macros for values of poor-mans-enumerated-type columns |
257 | */ |
258 | #define TYPTYPE_BASE 'b' /* base type (ordinary scalar type) */ |
259 | #define TYPTYPE_COMPOSITE 'c' /* composite (e.g., table's rowtype) */ |
260 | #define TYPTYPE_DOMAIN 'd' /* domain over another type */ |
261 | #define TYPTYPE_ENUM 'e' /* enumerated type */ |
262 | #define TYPTYPE_PSEUDO 'p' /* pseudo-type */ |
263 | #define TYPTYPE_RANGE 'r' /* range type */ |
264 | |
265 | #define TYPCATEGORY_INVALID '\0' /* not an allowed category */ |
266 | #define TYPCATEGORY_ARRAY 'A' |
267 | #define TYPCATEGORY_BOOLEAN 'B' |
268 | #define TYPCATEGORY_COMPOSITE 'C' |
269 | #define TYPCATEGORY_DATETIME 'D' |
270 | #define TYPCATEGORY_ENUM 'E' |
271 | #define TYPCATEGORY_GEOMETRIC 'G' |
272 | #define TYPCATEGORY_NETWORK 'I' /* think INET */ |
273 | #define TYPCATEGORY_NUMERIC 'N' |
274 | #define TYPCATEGORY_PSEUDOTYPE 'P' |
275 | #define TYPCATEGORY_RANGE 'R' |
276 | #define TYPCATEGORY_STRING 'S' |
277 | #define TYPCATEGORY_TIMESPAN 'T' |
278 | #define TYPCATEGORY_USER 'U' |
279 | #define TYPCATEGORY_BITSTRING 'V' /* er ... "varbit"? */ |
280 | #define TYPCATEGORY_UNKNOWN 'X' |
281 | |
282 | /* Is a type OID a polymorphic pseudotype? (Beware of multiple evaluation) */ |
283 | #define IsPolymorphicType(typid) \ |
284 | ((typid) == ANYELEMENTOID || \ |
285 | (typid) == ANYARRAYOID || \ |
286 | (typid) == ANYNONARRAYOID || \ |
287 | (typid) == ANYENUMOID || \ |
288 | (typid) == ANYRANGEOID) |
289 | |
290 | #endif /* EXPOSE_TO_CLIENT_CODE */ |
291 | |
292 | |
293 | extern ObjectAddress TypeShellMake(const char *typeName, |
294 | Oid typeNamespace, |
295 | Oid ownerId); |
296 | |
297 | extern ObjectAddress TypeCreate(Oid newTypeOid, |
298 | const char *typeName, |
299 | Oid typeNamespace, |
300 | Oid relationOid, |
301 | char relationKind, |
302 | Oid ownerId, |
303 | int16 internalSize, |
304 | char typeType, |
305 | char typeCategory, |
306 | bool typePreferred, |
307 | char typDelim, |
308 | Oid inputProcedure, |
309 | Oid outputProcedure, |
310 | Oid receiveProcedure, |
311 | Oid sendProcedure, |
312 | Oid typmodinProcedure, |
313 | Oid typmodoutProcedure, |
314 | Oid analyzeProcedure, |
315 | Oid elementType, |
316 | bool isImplicitArray, |
317 | Oid arrayType, |
318 | Oid baseType, |
319 | const char *defaultTypeValue, |
320 | char *defaultTypeBin, |
321 | bool passedByValue, |
322 | char alignment, |
323 | char storage, |
324 | int32 typeMod, |
325 | int32 typNDims, |
326 | bool typeNotNull, |
327 | Oid typeCollation); |
328 | |
329 | extern void GenerateTypeDependencies(Oid typeObjectId, |
330 | Form_pg_type typeForm, |
331 | Node *defaultExpr, |
332 | void *typacl, |
333 | char relationKind, /* only for relation |
334 | * rowtypes */ |
335 | bool isImplicitArray, |
336 | bool isDependentType, |
337 | bool rebuild); |
338 | |
339 | extern void RenameTypeInternal(Oid typeOid, const char *newTypeName, |
340 | Oid typeNamespace); |
341 | |
342 | extern char *makeArrayTypeName(const char *typeName, Oid typeNamespace); |
343 | |
344 | extern bool moveArrayTypeName(Oid typeOid, const char *typeName, |
345 | Oid typeNamespace); |
346 | |
347 | #endif /* PG_TYPE_H */ |
348 | |