PostgreSQL Source Code  git master
format_type.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * format_type.c
4  * Display type names "nicely".
5  *
6  *
7  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  * IDENTIFICATION
11  * src/backend/utils/adt/format_type.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 
16 #include "postgres.h"
17 
18 #include <ctype.h>
19 
20 #include "access/htup_details.h"
21 #include "catalog/namespace.h"
22 #include "catalog/pg_type.h"
23 #include "mb/pg_wchar.h"
24 #include "utils/builtins.h"
25 #include "utils/fmgroids.h"
26 #include "utils/lsyscache.h"
27 #include "utils/numeric.h"
28 #include "utils/syscache.h"
29 
30 static char *printTypmod(const char *typname, int32 typmod, Oid typmodout);
31 
32 
33 /*
34  * SQL function: format_type(type_oid, typemod)
35  *
36  * `type_oid' is from pg_type.oid, `typemod' is from
37  * pg_attribute.atttypmod. This function will get the type name and
38  * format it and the modifier to canonical SQL format, if the type is
39  * a standard type. Otherwise you just get pg_type.typname back,
40  * double quoted if it contains funny characters or matches a keyword.
41  *
42  * If typemod is NULL then we are formatting a type name in a context where
43  * no typemod is available, eg a function argument or result type. This
44  * yields a slightly different result from specifying typemod = -1 in some
45  * cases. Given typemod = -1 we feel compelled to produce an output that
46  * the parser will interpret as having typemod -1, so that pg_dump will
47  * produce CREATE TABLE commands that recreate the original state. But
48  * given NULL typemod, we assume that the parser's interpretation of
49  * typemod doesn't matter, and so we are willing to output a slightly
50  * "prettier" representation of the same type. For example, type = bpchar
51  * and typemod = NULL gets you "character", whereas typemod = -1 gets you
52  * "bpchar" --- the former will be interpreted as character(1) by the
53  * parser, which does not yield typemod -1.
54  *
55  * XXX encoding a meaning in typemod = NULL is ugly; it'd have been
56  * cleaner to make two functions of one and two arguments respectively.
57  * Not worth changing it now, however.
58  */
59 Datum
61 {
62  Oid type_oid;
63  int32 typemod;
64  char *result;
66 
67  /* Since this function is not strict, we must test for null args */
68  if (PG_ARGISNULL(0))
70 
71  type_oid = PG_GETARG_OID(0);
72 
73  if (PG_ARGISNULL(1))
74  typemod = -1;
75  else
76  {
77  typemod = PG_GETARG_INT32(1);
79  }
80 
81  result = format_type_extended(type_oid, typemod, flags);
82 
84 }
85 
86 /*
87  * format_type_extended
88  * Generate a possibly-qualified type name.
89  *
90  * The default behavior is to only qualify if the type is not in the search
91  * path, to ignore the given typmod, and to raise an error if a non-existent
92  * type_oid is given.
93  *
94  * The following bits in 'flags' modify the behavior:
95  * - FORMAT_TYPE_TYPEMOD_GIVEN
96  * include the typmod in the output (typmod could still be -1 though)
97  * - FORMAT_TYPE_ALLOW_INVALID
98  * if the type OID is invalid or unknown, return ??? or such instead
99  * of failing
100  * - FORMAT_TYPE_INVALID_AS_NULL
101  * if the type OID is invalid or unknown, return NULL instead of ???
102  * or such
103  * - FORMAT_TYPE_FORCE_QUALIFY
104  * always schema-qualify type names, regardless of search_path
105  *
106  * Note that TYPEMOD_GIVEN is not interchangeable with "typemod == -1";
107  * see the comments above for format_type().
108  *
109  * Returns a palloc'd string, or NULL.
110  */
111 char *
112 format_type_extended(Oid type_oid, int32 typemod, bits16 flags)
113 {
114  HeapTuple tuple;
115  Form_pg_type typeform;
116  Oid array_base_type;
117  bool is_array;
118  char *buf;
119  bool with_typemod;
120 
121  if (type_oid == InvalidOid)
122  {
123  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
124  return NULL;
125  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
126  return pstrdup("-");
127  }
128 
129  tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
130  if (!HeapTupleIsValid(tuple))
131  {
132  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
133  return NULL;
134  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
135  return pstrdup("???");
136  else
137  elog(ERROR, "cache lookup failed for type %u", type_oid);
138  }
139  typeform = (Form_pg_type) GETSTRUCT(tuple);
140 
141  /*
142  * Check if it's a "true" array type. Pseudo-array types such as "name"
143  * shouldn't get deconstructed. Also check the toast property, and don't
144  * deconstruct "plain storage" array types --- this is because we don't
145  * want to show oidvector as oid[].
146  */
147  array_base_type = typeform->typelem;
148 
149  if (IsTrueArrayType(typeform) &&
150  typeform->typstorage != TYPSTORAGE_PLAIN)
151  {
152  /* Switch our attention to the array element type */
153  ReleaseSysCache(tuple);
154  tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
155  if (!HeapTupleIsValid(tuple))
156  {
157  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
158  return NULL;
159  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
160  return pstrdup("???[]");
161  else
162  elog(ERROR, "cache lookup failed for type %u", type_oid);
163  }
164  typeform = (Form_pg_type) GETSTRUCT(tuple);
165  type_oid = array_base_type;
166  is_array = true;
167  }
168  else
169  is_array = false;
170 
171  with_typemod = (flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0 && (typemod >= 0);
172 
173  /*
174  * See if we want to special-case the output for certain built-in types.
175  * Note that these special cases should all correspond to special
176  * productions in gram.y, to ensure that the type name will be taken as a
177  * system type, not a user type of the same name.
178  *
179  * If we do not provide a special-case output here, the type name will be
180  * handled the same way as a user type name --- in particular, it will be
181  * double-quoted if it matches any lexer keyword. This behavior is
182  * essential for some cases, such as types "bit" and "char".
183  */
184  buf = NULL; /* flag for no special case */
185 
186  switch (type_oid)
187  {
188  case BITOID:
189  if (with_typemod)
190  buf = printTypmod("bit", typemod, typeform->typmodout);
191  else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
192  {
193  /*
194  * bit with typmod -1 is not the same as BIT, which means
195  * BIT(1) per SQL spec. Report it as the quoted typename so
196  * that parser will not assign a bogus typmod.
197  */
198  }
199  else
200  buf = pstrdup("bit");
201  break;
202 
203  case BOOLOID:
204  buf = pstrdup("boolean");
205  break;
206 
207  case BPCHAROID:
208  if (with_typemod)
209  buf = printTypmod("character", typemod, typeform->typmodout);
210  else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
211  {
212  /*
213  * bpchar with typmod -1 is not the same as CHARACTER, which
214  * means CHARACTER(1) per SQL spec. Report it as bpchar so
215  * that parser will not assign a bogus typmod.
216  */
217  }
218  else
219  buf = pstrdup("character");
220  break;
221 
222  case FLOAT4OID:
223  buf = pstrdup("real");
224  break;
225 
226  case FLOAT8OID:
227  buf = pstrdup("double precision");
228  break;
229 
230  case INT2OID:
231  buf = pstrdup("smallint");
232  break;
233 
234  case INT4OID:
235  buf = pstrdup("integer");
236  break;
237 
238  case INT8OID:
239  buf = pstrdup("bigint");
240  break;
241 
242  case NUMERICOID:
243  if (with_typemod)
244  buf = printTypmod("numeric", typemod, typeform->typmodout);
245  else
246  buf = pstrdup("numeric");
247  break;
248 
249  case INTERVALOID:
250  if (with_typemod)
251  buf = printTypmod("interval", typemod, typeform->typmodout);
252  else
253  buf = pstrdup("interval");
254  break;
255 
256  case TIMEOID:
257  if (with_typemod)
258  buf = printTypmod("time", typemod, typeform->typmodout);
259  else
260  buf = pstrdup("time without time zone");
261  break;
262 
263  case TIMETZOID:
264  if (with_typemod)
265  buf = printTypmod("time", typemod, typeform->typmodout);
266  else
267  buf = pstrdup("time with time zone");
268  break;
269 
270  case TIMESTAMPOID:
271  if (with_typemod)
272  buf = printTypmod("timestamp", typemod, typeform->typmodout);
273  else
274  buf = pstrdup("timestamp without time zone");
275  break;
276 
277  case TIMESTAMPTZOID:
278  if (with_typemod)
279  buf = printTypmod("timestamp", typemod, typeform->typmodout);
280  else
281  buf = pstrdup("timestamp with time zone");
282  break;
283 
284  case VARBITOID:
285  if (with_typemod)
286  buf = printTypmod("bit varying", typemod, typeform->typmodout);
287  else
288  buf = pstrdup("bit varying");
289  break;
290 
291  case VARCHAROID:
292  if (with_typemod)
293  buf = printTypmod("character varying", typemod, typeform->typmodout);
294  else
295  buf = pstrdup("character varying");
296  break;
297  }
298 
299  if (buf == NULL)
300  {
301  /*
302  * Default handling: report the name as it appears in the catalog.
303  * Here, we must qualify the name if it is not visible in the search
304  * path or if caller requests it; and we must double-quote it if it's
305  * not a standard identifier or if it matches any keyword.
306  */
307  char *nspname;
308  char *typname;
309 
310  if ((flags & FORMAT_TYPE_FORCE_QUALIFY) == 0 &&
311  TypeIsVisible(type_oid))
312  nspname = NULL;
313  else
314  nspname = get_namespace_name_or_temp(typeform->typnamespace);
315 
316  typname = NameStr(typeform->typname);
317 
318  buf = quote_qualified_identifier(nspname, typname);
319 
320  if (with_typemod)
321  buf = printTypmod(buf, typemod, typeform->typmodout);
322  }
323 
324  if (is_array)
325  buf = psprintf("%s[]", buf);
326 
327  ReleaseSysCache(tuple);
328 
329  return buf;
330 }
331 
332 /*
333  * This version is for use within the backend in error messages, etc.
334  * One difference is that it will fail for an invalid type.
335  *
336  * The result is always a palloc'd string.
337  */
338 char *
340 {
341  return format_type_extended(type_oid, -1, 0);
342 }
343 
344 /*
345  * This version returns a name that is always qualified (unless it's one
346  * of the SQL-keyword type names, such as TIMESTAMP WITH TIME ZONE).
347  */
348 char *
350 {
351  return format_type_extended(type_oid, -1, FORMAT_TYPE_FORCE_QUALIFY);
352 }
353 
354 /*
355  * This version allows a nondefault typemod to be specified.
356  */
357 char *
359 {
360  return format_type_extended(type_oid, typemod, FORMAT_TYPE_TYPEMOD_GIVEN);
361 }
362 
363 /*
364  * Add typmod decoration to the basic type name
365  */
366 static char *
367 printTypmod(const char *typname, int32 typmod, Oid typmodout)
368 {
369  char *res;
370 
371  /* Shouldn't be called if typmod is -1 */
372  Assert(typmod >= 0);
373 
374  if (typmodout == InvalidOid)
375  {
376  /* Default behavior: just print the integer typmod with parens */
377  res = psprintf("%s(%d)", typname, (int) typmod);
378  }
379  else
380  {
381  /* Use the type-specific typmodout procedure */
382  char *tmstr;
383 
384  tmstr = DatumGetCString(OidFunctionCall1(typmodout,
385  Int32GetDatum(typmod)));
386  res = psprintf("%s%s", typname, tmstr);
387  }
388 
389  return res;
390 }
391 
392 
393 /*
394  * type_maximum_size --- determine maximum width of a variable-width column
395  *
396  * If the max width is indeterminate, return -1. In particular, we return
397  * -1 for any type not known to this routine. We assume the caller has
398  * already determined that the type is a variable-width type, so it's not
399  * necessary to look up the type's pg_type tuple here.
400  *
401  * This may appear unrelated to format_type(), but in fact the two routines
402  * share knowledge of the encoding of typmod for different types, so it's
403  * convenient to keep them together. (XXX now that most of this knowledge
404  * has been pushed out of format_type into the typmodout functions, it's
405  * interesting to wonder if it's worth trying to factor this code too...)
406  */
407 int32
408 type_maximum_size(Oid type_oid, int32 typemod)
409 {
410  if (typemod < 0)
411  return -1;
412 
413  switch (type_oid)
414  {
415  case BPCHAROID:
416  case VARCHAROID:
417  /* typemod includes varlena header */
418 
419  /* typemod is in characters not bytes */
420  return (typemod - VARHDRSZ) *
422  + VARHDRSZ;
423 
424  case NUMERICOID:
425  return numeric_maximum_size(typemod);
426 
427  case VARBITOID:
428  case BITOID:
429  /* typemod is the (max) number of bits */
430  return (typemod + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE
431  + 2 * sizeof(int32);
432  }
433 
434  /* Unknown type, or unlimited-width type such as 'text' */
435  return -1;
436 }
437 
438 
439 /*
440  * oidvectortypes - converts a vector of type OIDs to "typname" list
441  */
442 Datum
444 {
445  oidvector *oidArray = (oidvector *) PG_GETARG_POINTER(0);
446  char *result;
447  int numargs = oidArray->dim1;
448  int num;
449  size_t total;
450  size_t left;
451 
452  total = 20 * numargs + 1;
453  result = palloc(total);
454  result[0] = '\0';
455  left = total - 1;
456 
457  for (num = 0; num < numargs; num++)
458  {
459  char *typename = format_type_extended(oidArray->values[num], -1,
461  size_t slen = strlen(typename);
462 
463  if (left < (slen + 2))
464  {
465  total += slen + 2;
466  result = repalloc(result, total);
467  left += slen + 2;
468  }
469 
470  if (num > 0)
471  {
472  strcat(result, ", ");
473  left -= 2;
474  }
475  strcat(result, typename);
476  left -= slen;
477  }
478 
480 }
Definition: c.h:660
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
#define BITS_PER_BYTE
uint16 bits16
Definition: c.h:449
#define VARHDRSZ
Definition: c.h:627
char * pstrdup(const char *in)
Definition: mcxt.c:1187
#define FORMAT_TYPE_TYPEMOD_GIVEN
Definition: builtins.h:108
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
unsigned int Oid
Definition: postgres_ext.h:31
signed int int32
Definition: c.h:429
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:45
#define DatumGetCString(X)
Definition: postgres.h:566
int32 type_maximum_size(Oid type_oid, int32 typemod)
Definition: format_type.c:408
#define OidFunctionCall1(functionId, arg1)
Definition: fmgr.h:664
int pg_encoding_max_length(int encoding)
Definition: wchar.c:1964
static char * buf
Definition: pg_test_fsync.c:68
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:668
int dim1
Definition: c.h:666
#define FORMAT_TYPE_FORCE_QUALIFY
Definition: builtins.h:110
Datum oidvectortypes(PG_FUNCTION_ARGS)
Definition: format_type.c:443
NameData typname
Definition: pg_type.h:41
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition: ruleutils.c:11078
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1127
#define FORMAT_TYPE_ALLOW_INVALID
Definition: builtins.h:109
char * format_type_with_typemod(Oid type_oid, int32 typemod)
Definition: format_type.c:358
#define FORMAT_TYPE_INVALID_AS_NULL
Definition: builtins.h:111
uintptr_t Datum
Definition: postgres.h:367
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1175
int GetDatabaseEncoding(void)
Definition: mbutils.c:1151
#define InvalidOid
Definition: postgres_ext.h:36
int32 numeric_maximum_size(int32 typmod)
Definition: numeric.c:820
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
text * cstring_to_text(const char *s)
Definition: varlena.c:189
#define PG_ARGISNULL(n)
Definition: fmgr.h:209
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define Assert(condition)
Definition: c.h:804
bool TypeIsVisible(Oid typid)
Definition: namespace.c:816
char * format_type_be_qualified(Oid type_oid)
Definition: format_type.c:349
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
char * format_type_extended(Oid type_oid, int32 typemod, bits16 flags)
Definition: format_type.c:112
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1070
static char * printTypmod(const char *typname, int32 typmod, Oid typmodout)
Definition: format_type.c:367
#define Int32GetDatum(X)
Definition: postgres.h:479
void * palloc(Size size)
Definition: mcxt.c:950
char * get_namespace_name_or_temp(Oid nspid)
Definition: lsyscache.c:3340
#define elog(elevel,...)
Definition: elog.h:227
#define NameStr(name)
Definition: c.h:681
Datum format_type(PG_FUNCTION_ARGS)
Definition: format_type.c:60
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_NULL()
Definition: fmgr.h:345