PostgreSQL Source Code  git master
parse_type.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_type.c
4  * handle type operations for parser
5  *
6  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/parser/parse_type.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include "access/htup_details.h"
18 #include "catalog/namespace.h"
19 #include "catalog/pg_type.h"
20 #include "lib/stringinfo.h"
21 #include "nodes/makefuncs.h"
22 #include "parser/parse_type.h"
23 #include "parser/parser.h"
24 #include "utils/array.h"
25 #include "utils/builtins.h"
26 #include "utils/lsyscache.h"
27 #include "utils/syscache.h"
28 
29 static int32 typenameTypeMod(ParseState *pstate, const TypeName *typeName,
30  Type typ);
31 
32 
33 /*
34  * LookupTypeName
35  * Wrapper for typical case.
36  */
37 Type
38 LookupTypeName(ParseState *pstate, const TypeName *typeName,
39  int32 *typmod_p, bool missing_ok)
40 {
41  return LookupTypeNameExtended(pstate,
42  typeName, typmod_p, true, missing_ok);
43 }
44 
45 /*
46  * LookupTypeNameExtended
47  * Given a TypeName object, lookup the pg_type syscache entry of the type.
48  * Returns NULL if no such type can be found. If the type is found,
49  * the typmod value represented in the TypeName struct is computed and
50  * stored into *typmod_p.
51  *
52  * NB: on success, the caller must ReleaseSysCache the type tuple when done
53  * with it.
54  *
55  * NB: direct callers of this function MUST check typisdefined before assuming
56  * that the type is fully valid. Most code should go through typenameType
57  * or typenameTypeId instead.
58  *
59  * typmod_p can be passed as NULL if the caller does not care to know the
60  * typmod value, but the typmod decoration (if any) will be validated anyway,
61  * except in the case where the type is not found. Note that if the type is
62  * found but is a shell, and there is typmod decoration, an error will be
63  * thrown --- this is intentional.
64  *
65  * If temp_ok is false, ignore types in the temporary namespace. Pass false
66  * when the caller will decide, using goodness of fit criteria, whether the
67  * typeName is actually a type or something else. If typeName always denotes
68  * a type (or denotes nothing), pass true.
69  *
70  * pstate is only used for error location info, and may be NULL.
71  */
72 Type
74  const TypeName *typeName, int32 *typmod_p,
75  bool temp_ok, bool missing_ok)
76 {
77  Oid typoid;
78  HeapTuple tup;
79  int32 typmod;
80 
81  if (typeName->names == NIL)
82  {
83  /* We have the OID already if it's an internally generated TypeName */
84  typoid = typeName->typeOid;
85  }
86  else if (typeName->pct_type)
87  {
88  /* Handle %TYPE reference to type of an existing field */
89  RangeVar *rel = makeRangeVar(NULL, NULL, typeName->location);
90  char *field = NULL;
91  Oid relid;
93 
94  /* deconstruct the name list */
95  switch (list_length(typeName->names))
96  {
97  case 1:
98  ereport(ERROR,
99  (errcode(ERRCODE_SYNTAX_ERROR),
100  errmsg("improper %%TYPE reference (too few dotted names): %s",
101  NameListToString(typeName->names)),
102  parser_errposition(pstate, typeName->location)));
103  break;
104  case 2:
105  rel->relname = strVal(linitial(typeName->names));
106  field = strVal(lsecond(typeName->names));
107  break;
108  case 3:
109  rel->schemaname = strVal(linitial(typeName->names));
110  rel->relname = strVal(lsecond(typeName->names));
111  field = strVal(lthird(typeName->names));
112  break;
113  case 4:
114  rel->catalogname = strVal(linitial(typeName->names));
115  rel->schemaname = strVal(lsecond(typeName->names));
116  rel->relname = strVal(lthird(typeName->names));
117  field = strVal(lfourth(typeName->names));
118  break;
119  default:
120  ereport(ERROR,
121  (errcode(ERRCODE_SYNTAX_ERROR),
122  errmsg("improper %%TYPE reference (too many dotted names): %s",
123  NameListToString(typeName->names)),
124  parser_errposition(pstate, typeName->location)));
125  break;
126  }
127 
128  /*
129  * Look up the field.
130  *
131  * XXX: As no lock is taken here, this might fail in the presence of
132  * concurrent DDL. But taking a lock would carry a performance
133  * penalty and would also require a permissions check.
134  */
135  relid = RangeVarGetRelid(rel, NoLock, missing_ok);
136  attnum = get_attnum(relid, field);
137  if (attnum == InvalidAttrNumber)
138  {
139  if (missing_ok)
140  typoid = InvalidOid;
141  else
142  ereport(ERROR,
143  (errcode(ERRCODE_UNDEFINED_COLUMN),
144  errmsg("column \"%s\" of relation \"%s\" does not exist",
145  field, rel->relname),
146  parser_errposition(pstate, typeName->location)));
147  }
148  else
149  {
150  typoid = get_atttype(relid, attnum);
151 
152  /* this construct should never have an array indicator */
153  Assert(typeName->arrayBounds == NIL);
154 
155  /* emit nuisance notice (intentionally not errposition'd) */
156  ereport(NOTICE,
157  (errmsg("type reference %s converted to %s",
158  TypeNameToString(typeName),
159  format_type_be(typoid))));
160  }
161  }
162  else
163  {
164  /* Normal reference to a type name */
165  char *schemaname;
166  char *typname;
167 
168  /* deconstruct the name list */
169  DeconstructQualifiedName(typeName->names, &schemaname, &typname);
170 
171  if (schemaname)
172  {
173  /* Look in specific schema only */
174  Oid namespaceId;
175  ParseCallbackState pcbstate;
176 
177  setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
178 
179  namespaceId = LookupExplicitNamespace(schemaname, missing_ok);
180  if (OidIsValid(namespaceId))
181  typoid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
182  PointerGetDatum(typname),
183  ObjectIdGetDatum(namespaceId));
184  else
185  typoid = InvalidOid;
186 
188  }
189  else
190  {
191  /* Unqualified type name, so search the search path */
192  typoid = TypenameGetTypidExtended(typname, temp_ok);
193  }
194 
195  /* If an array reference, return the array type instead */
196  if (typeName->arrayBounds != NIL)
197  typoid = get_array_type(typoid);
198  }
199 
200  if (!OidIsValid(typoid))
201  {
202  if (typmod_p)
203  *typmod_p = -1;
204  return NULL;
205  }
206 
207  tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typoid));
208  if (!HeapTupleIsValid(tup)) /* should not happen */
209  elog(ERROR, "cache lookup failed for type %u", typoid);
210 
211  typmod = typenameTypeMod(pstate, typeName, (Type) tup);
212 
213  if (typmod_p)
214  *typmod_p = typmod;
215 
216  return (Type) tup;
217 }
218 
219 /*
220  * LookupTypeNameOid
221  * Given a TypeName object, lookup the pg_type syscache entry of the type.
222  * Returns InvalidOid if no such type can be found. If the type is found,
223  * return its Oid.
224  *
225  * NB: direct callers of this function need to be aware that the type OID
226  * returned may correspond to a shell type. Most code should go through
227  * typenameTypeId instead.
228  *
229  * pstate is only used for error location info, and may be NULL.
230  */
231 Oid
232 LookupTypeNameOid(ParseState *pstate, const TypeName *typeName, bool missing_ok)
233 {
234  Oid typoid;
235  Type tup;
236 
237  tup = LookupTypeName(pstate, typeName, NULL, missing_ok);
238  if (tup == NULL)
239  {
240  if (!missing_ok)
241  ereport(ERROR,
242  (errcode(ERRCODE_UNDEFINED_OBJECT),
243  errmsg("type \"%s\" does not exist",
244  TypeNameToString(typeName)),
245  parser_errposition(pstate, typeName->location)));
246 
247  return InvalidOid;
248  }
249 
250  typoid = ((Form_pg_type) GETSTRUCT(tup))->oid;
251  ReleaseSysCache(tup);
252 
253  return typoid;
254 }
255 
256 /*
257  * typenameType - given a TypeName, return a Type structure and typmod
258  *
259  * This is equivalent to LookupTypeName, except that this will report
260  * a suitable error message if the type cannot be found or is not defined.
261  * Callers of this can therefore assume the result is a fully valid type.
262  */
263 Type
264 typenameType(ParseState *pstate, const TypeName *typeName, int32 *typmod_p)
265 {
266  Type tup;
267 
268  tup = LookupTypeName(pstate, typeName, typmod_p, false);
269  if (tup == NULL)
270  ereport(ERROR,
271  (errcode(ERRCODE_UNDEFINED_OBJECT),
272  errmsg("type \"%s\" does not exist",
273  TypeNameToString(typeName)),
274  parser_errposition(pstate, typeName->location)));
275  if (!((Form_pg_type) GETSTRUCT(tup))->typisdefined)
276  ereport(ERROR,
277  (errcode(ERRCODE_UNDEFINED_OBJECT),
278  errmsg("type \"%s\" is only a shell",
279  TypeNameToString(typeName)),
280  parser_errposition(pstate, typeName->location)));
281  return tup;
282 }
283 
284 /*
285  * typenameTypeId - given a TypeName, return the type's OID
286  *
287  * This is similar to typenameType, but we only hand back the type OID
288  * not the syscache entry.
289  */
290 Oid
291 typenameTypeId(ParseState *pstate, const TypeName *typeName)
292 {
293  Oid typoid;
294  Type tup;
295 
296  tup = typenameType(pstate, typeName, NULL);
297  typoid = ((Form_pg_type) GETSTRUCT(tup))->oid;
298  ReleaseSysCache(tup);
299 
300  return typoid;
301 }
302 
303 /*
304  * typenameTypeIdAndMod - given a TypeName, return the type's OID and typmod
305  *
306  * This is equivalent to typenameType, but we only hand back the type OID
307  * and typmod, not the syscache entry.
308  */
309 void
310 typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName,
311  Oid *typeid_p, int32 *typmod_p)
312 {
313  Type tup;
314 
315  tup = typenameType(pstate, typeName, typmod_p);
316  *typeid_p = ((Form_pg_type) GETSTRUCT(tup))->oid;
317  ReleaseSysCache(tup);
318 }
319 
320 /*
321  * typenameTypeMod - given a TypeName, return the internal typmod value
322  *
323  * This will throw an error if the TypeName includes type modifiers that are
324  * illegal for the data type.
325  *
326  * The actual type OID represented by the TypeName must already have been
327  * looked up, and is passed as "typ".
328  *
329  * pstate is only used for error location info, and may be NULL.
330  */
331 static int32
332 typenameTypeMod(ParseState *pstate, const TypeName *typeName, Type typ)
333 {
334  int32 result;
335  Oid typmodin;
336  Datum *datums;
337  int n;
338  ListCell *l;
339  ArrayType *arrtypmod;
340  ParseCallbackState pcbstate;
341 
342  /* Return prespecified typmod if no typmod expressions */
343  if (typeName->typmods == NIL)
344  return typeName->typemod;
345 
346  /*
347  * Else, type had better accept typmods. We give a special error message
348  * for the shell-type case, since a shell couldn't possibly have a
349  * typmodin function.
350  */
351  if (!((Form_pg_type) GETSTRUCT(typ))->typisdefined)
352  ereport(ERROR,
353  (errcode(ERRCODE_SYNTAX_ERROR),
354  errmsg("type modifier cannot be specified for shell type \"%s\"",
355  TypeNameToString(typeName)),
356  parser_errposition(pstate, typeName->location)));
357 
358  typmodin = ((Form_pg_type) GETSTRUCT(typ))->typmodin;
359 
360  if (typmodin == InvalidOid)
361  ereport(ERROR,
362  (errcode(ERRCODE_SYNTAX_ERROR),
363  errmsg("type modifier is not allowed for type \"%s\"",
364  TypeNameToString(typeName)),
365  parser_errposition(pstate, typeName->location)));
366 
367  /*
368  * Convert the list of raw-grammar-output expressions to a cstring array.
369  * Currently, we allow simple numeric constants, string literals, and
370  * identifiers; possibly this list could be extended.
371  */
372  datums = (Datum *) palloc(list_length(typeName->typmods) * sizeof(Datum));
373  n = 0;
374  foreach(l, typeName->typmods)
375  {
376  Node *tm = (Node *) lfirst(l);
377  char *cstr = NULL;
378 
379  if (IsA(tm, A_Const))
380  {
381  A_Const *ac = (A_Const *) tm;
382 
383  if (IsA(&ac->val, Integer))
384  {
385  cstr = psprintf("%ld", (long) ac->val.ival.val);
386  }
387  else if (IsA(&ac->val, Float))
388  {
389  /* we can just use the string representation directly. */
390  cstr = ac->val.fval.val;
391  }
392  else if (IsA(&ac->val, String))
393  {
394  /* we can just use the string representation directly. */
395  cstr = ac->val.sval.val;
396  }
397  }
398  else if (IsA(tm, ColumnRef))
399  {
400  ColumnRef *cr = (ColumnRef *) tm;
401 
402  if (list_length(cr->fields) == 1 &&
403  IsA(linitial(cr->fields), String))
404  cstr = strVal(linitial(cr->fields));
405  }
406  if (!cstr)
407  ereport(ERROR,
408  (errcode(ERRCODE_SYNTAX_ERROR),
409  errmsg("type modifiers must be simple constants or identifiers"),
410  parser_errposition(pstate, typeName->location)));
411  datums[n++] = CStringGetDatum(cstr);
412  }
413 
414  /* hardwired knowledge about cstring's representation details here */
415  arrtypmod = construct_array(datums, n, CSTRINGOID,
416  -2, false, TYPALIGN_CHAR);
417 
418  /* arrange to report location if type's typmodin function fails */
419  setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
420 
421  result = DatumGetInt32(OidFunctionCall1(typmodin,
422  PointerGetDatum(arrtypmod)));
423 
425 
426  pfree(datums);
427  pfree(arrtypmod);
428 
429  return result;
430 }
431 
432 /*
433  * appendTypeNameToBuffer
434  * Append a string representing the name of a TypeName to a StringInfo.
435  * This is the shared guts of TypeNameToString and TypeNameListToString.
436  *
437  * NB: this must work on TypeNames that do not describe any actual type;
438  * it is mostly used for reporting lookup errors.
439  */
440 static void
442 {
443  if (typeName->names != NIL)
444  {
445  /* Emit possibly-qualified name as-is */
446  ListCell *l;
447 
448  foreach(l, typeName->names)
449  {
450  if (l != list_head(typeName->names))
451  appendStringInfoChar(string, '.');
452  appendStringInfoString(string, strVal(lfirst(l)));
453  }
454  }
455  else
456  {
457  /* Look up internally-specified type */
458  appendStringInfoString(string, format_type_be(typeName->typeOid));
459  }
460 
461  /*
462  * Add decoration as needed, but only for fields considered by
463  * LookupTypeName
464  */
465  if (typeName->pct_type)
466  appendStringInfoString(string, "%TYPE");
467 
468  if (typeName->arrayBounds != NIL)
469  appendStringInfoString(string, "[]");
470 }
471 
472 /*
473  * TypeNameToString
474  * Produce a string representing the name of a TypeName.
475  *
476  * NB: this must work on TypeNames that do not describe any actual type;
477  * it is mostly used for reporting lookup errors.
478  */
479 char *
480 TypeNameToString(const TypeName *typeName)
481 {
483 
484  initStringInfo(&string);
485  appendTypeNameToBuffer(typeName, &string);
486  return string.data;
487 }
488 
489 /*
490  * TypeNameListToString
491  * Produce a string representing the name(s) of a List of TypeNames
492  */
493 char *
495 {
497  ListCell *l;
498 
499  initStringInfo(&string);
500  foreach(l, typenames)
501  {
502  TypeName *typeName = lfirst_node(TypeName, l);
503 
504  if (l != list_head(typenames))
505  appendStringInfoChar(&string, ',');
506  appendTypeNameToBuffer(typeName, &string);
507  }
508  return string.data;
509 }
510 
511 /*
512  * LookupCollation
513  *
514  * Look up collation by name, return OID, with support for error location.
515  */
516 Oid
517 LookupCollation(ParseState *pstate, List *collnames, int location)
518 {
519  Oid colloid;
520  ParseCallbackState pcbstate;
521 
522  if (pstate)
523  setup_parser_errposition_callback(&pcbstate, pstate, location);
524 
525  colloid = get_collation_oid(collnames, false);
526 
527  if (pstate)
529 
530  return colloid;
531 }
532 
533 /*
534  * GetColumnDefCollation
535  *
536  * Get the collation to be used for a column being defined, given the
537  * ColumnDef node and the previously-determined column type OID.
538  *
539  * pstate is only used for error location purposes, and can be NULL.
540  */
541 Oid
542 GetColumnDefCollation(ParseState *pstate, ColumnDef *coldef, Oid typeOid)
543 {
544  Oid result;
545  Oid typcollation = get_typcollation(typeOid);
546  int location = coldef->location;
547 
548  if (coldef->collClause)
549  {
550  /* We have a raw COLLATE clause, so look up the collation */
551  location = coldef->collClause->location;
552  result = LookupCollation(pstate, coldef->collClause->collname,
553  location);
554  }
555  else if (OidIsValid(coldef->collOid))
556  {
557  /* Precooked collation spec, use that */
558  result = coldef->collOid;
559  }
560  else
561  {
562  /* Use the type's default collation if any */
563  result = typcollation;
564  }
565 
566  /* Complain if COLLATE is applied to an uncollatable type */
567  if (OidIsValid(result) && !OidIsValid(typcollation))
568  ereport(ERROR,
569  (errcode(ERRCODE_DATATYPE_MISMATCH),
570  errmsg("collations are not supported by type %s",
571  format_type_be(typeOid)),
572  parser_errposition(pstate, location)));
573 
574  return result;
575 }
576 
577 /* return a Type structure, given a type id */
578 /* NB: caller must ReleaseSysCache the type tuple when done with it */
579 Type
581 {
582  HeapTuple tup;
583 
585  if (!HeapTupleIsValid(tup))
586  elog(ERROR, "cache lookup failed for type %u", id);
587  return (Type) tup;
588 }
589 
590 /* given type (as type struct), return the type OID */
591 Oid
593 {
594  if (tp == NULL) /* probably useless */
595  elog(ERROR, "typeTypeId() called with NULL type struct");
596  return ((Form_pg_type) GETSTRUCT(tp))->oid;
597 }
598 
599 /* given type (as type struct), return the length of type */
600 int16
602 {
603  Form_pg_type typ;
604 
605  typ = (Form_pg_type) GETSTRUCT(t);
606  return typ->typlen;
607 }
608 
609 /* given type (as type struct), return its 'byval' attribute */
610 bool
612 {
613  Form_pg_type typ;
614 
615  typ = (Form_pg_type) GETSTRUCT(t);
616  return typ->typbyval;
617 }
618 
619 /* given type (as type struct), return the type's name */
620 char *
622 {
623  Form_pg_type typ;
624 
625  typ = (Form_pg_type) GETSTRUCT(t);
626  /* pstrdup here because result may need to outlive the syscache entry */
627  return pstrdup(NameStr(typ->typname));
628 }
629 
630 /* given type (as type struct), return its 'typrelid' attribute */
631 Oid
633 {
634  Form_pg_type typtup;
635 
636  typtup = (Form_pg_type) GETSTRUCT(typ);
637  return typtup->typrelid;
638 }
639 
640 /* given type (as type struct), return its 'typcollation' attribute */
641 Oid
643 {
644  Form_pg_type typtup;
645 
646  typtup = (Form_pg_type) GETSTRUCT(typ);
647  return typtup->typcollation;
648 }
649 
650 /*
651  * Given a type structure and a string, returns the internal representation
652  * of that string. The "string" can be NULL to perform conversion of a NULL
653  * (which might result in failure, if the input function rejects NULLs).
654  */
655 Datum
656 stringTypeDatum(Type tp, char *string, int32 atttypmod)
657 {
658  Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp);
659  Oid typinput = typform->typinput;
660  Oid typioparam = getTypeIOParam(tp);
661 
662  return OidInputFunctionCall(typinput, string, typioparam, atttypmod);
663 }
664 
665 /*
666  * Given a typeid, return the type's typrelid (associated relation), if any.
667  * Returns InvalidOid if type is not a composite type.
668  */
669 Oid
671 {
672  HeapTuple typeTuple;
674  Oid result;
675 
676  typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
677  if (!HeapTupleIsValid(typeTuple))
678  elog(ERROR, "cache lookup failed for type %u", type_id);
679  type = (Form_pg_type) GETSTRUCT(typeTuple);
680  result = type->typrelid;
681  ReleaseSysCache(typeTuple);
682  return result;
683 }
684 
685 /*
686  * Given a typeid, return the type's typrelid (associated relation), if any.
687  * Returns InvalidOid if type is not a composite type or a domain over one.
688  * This is the same as typeidTypeRelid(getBaseType(type_id)), but faster.
689  */
690 Oid
692 {
693  HeapTuple typeTuple;
695  Oid result;
696 
697  for (;;)
698  {
699  typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
700  if (!HeapTupleIsValid(typeTuple))
701  elog(ERROR, "cache lookup failed for type %u", type_id);
702  type = (Form_pg_type) GETSTRUCT(typeTuple);
703  if (type->typtype != TYPTYPE_DOMAIN)
704  {
705  /* Not a domain, so done looking through domains */
706  break;
707  }
708  /* It is a domain, so examine the base type instead */
709  type_id = type->typbasetype;
710  ReleaseSysCache(typeTuple);
711  }
712  result = type->typrelid;
713  ReleaseSysCache(typeTuple);
714  return result;
715 }
716 
717 /*
718  * error context callback for parse failure during parseTypeString()
719  */
720 static void
722 {
723  const char *str = (const char *) arg;
724 
725  errcontext("invalid type name \"%s\"", str);
726 }
727 
728 /*
729  * Given a string that is supposed to be a SQL-compatible type declaration,
730  * such as "int4" or "integer" or "character varying(32)", parse
731  * the string and return the result as a TypeName.
732  * If the string cannot be parsed as a type, an error is raised.
733  */
734 TypeName *
736 {
737  List *raw_parsetree_list;
738  TypeName *typeName;
739  ErrorContextCallback ptserrcontext;
740 
741  /* make sure we give useful error for empty input */
742  if (strspn(str, " \t\n\r\f") == strlen(str))
743  goto fail;
744 
745  /*
746  * Setup error traceback support in case of ereport() during parse
747  */
748  ptserrcontext.callback = pts_error_callback;
749  ptserrcontext.arg = unconstify(char *, str);
750  ptserrcontext.previous = error_context_stack;
751  error_context_stack = &ptserrcontext;
752 
753  raw_parsetree_list = raw_parser(str, RAW_PARSE_TYPE_NAME);
754 
755  error_context_stack = ptserrcontext.previous;
756 
757  /* We should get back exactly one TypeName node. */
758  Assert(list_length(raw_parsetree_list) == 1);
759  typeName = linitial_node(TypeName, raw_parsetree_list);
760 
761  /* The grammar allows SETOF in TypeName, but we don't want that here. */
762  if (typeName->setof)
763  goto fail;
764 
765  return typeName;
766 
767 fail:
768  ereport(ERROR,
769  (errcode(ERRCODE_SYNTAX_ERROR),
770  errmsg("invalid type name \"%s\"", str)));
771  return NULL; /* keep compiler quiet */
772 }
773 
774 /*
775  * Given a string that is supposed to be a SQL-compatible type declaration,
776  * such as "int4" or "integer" or "character varying(32)", parse
777  * the string and convert it to a type OID and type modifier.
778  * If missing_ok is true, InvalidOid is returned rather than raising an error
779  * when the type name is not found.
780  */
781 void
782 parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok)
783 {
784  TypeName *typeName;
785  Type tup;
786 
787  typeName = typeStringToTypeName(str);
788 
789  tup = LookupTypeName(NULL, typeName, typmod_p, missing_ok);
790  if (tup == NULL)
791  {
792  if (!missing_ok)
793  ereport(ERROR,
794  (errcode(ERRCODE_UNDEFINED_OBJECT),
795  errmsg("type \"%s\" does not exist",
796  TypeNameToString(typeName)),
797  parser_errposition(NULL, typeName->location)));
798  *typeid_p = InvalidOid;
799  }
800  else
801  {
802  Form_pg_type typ = (Form_pg_type) GETSTRUCT(tup);
803 
804  if (!typ->typisdefined)
805  ereport(ERROR,
806  (errcode(ERRCODE_UNDEFINED_OBJECT),
807  errmsg("type \"%s\" is only a shell",
808  TypeNameToString(typeName)),
809  parser_errposition(NULL, typeName->location)));
810  *typeid_p = typ->oid;
811  ReleaseSysCache(tup);
812  }
813 }
Type LookupTypeName(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:38
signed short int16
Definition: c.h:428
#define NIL
Definition: pg_list.h:65
Type LookupTypeNameExtended(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool temp_ok, bool missing_ok)
Definition: parse_type.c:73
Oid typeTypeCollation(Type typ)
Definition: parse_type.c:642
Oid typeOid
Definition: parsenodes.h:222
#define IsA(nodeptr, _type_)
Definition: nodes.h:587
Oid LookupExplicitNamespace(const char *nspname, bool missing_ok)
Definition: namespace.c:2938
#define GETSTRUCT(TUP)
Definition: htup_details.h:654
Oid typeOrDomainTypeRelid(Oid type_id)
Definition: parse_type.c:691
Type typenameType(ParseState *pstate, const TypeName *typeName, int32 *typmod_p)
Definition: parse_type.c:264
List * names
Definition: parsenodes.h:221
#define DatumGetInt32(X)
Definition: postgres.h:516
int16 typeLen(Type t)
Definition: parse_type.c:601
#define PointerGetDatum(X)
Definition: postgres.h:600
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:79
char * TypeNameToString(const TypeName *typeName)
Definition: parse_type.c:480
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2734
char * pstrdup(const char *in)
Definition: mcxt.c:1299
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
Definition: arrayfuncs.c:3319
Definition: nodes.h:536
#define strVal(v)
Definition: value.h:65
int errcode(int sqlerrcode)
Definition: elog.c:698
Definition: value.h:51
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
char * TypeNameListToString(List *typenames)
Definition: parse_type.c:494
Oid typeidTypeRelid(Oid type_id)
Definition: parse_type.c:670
void DeconstructQualifiedName(List *names, char **nspname_p, char **objname_p)
Definition: namespace.c:2854
unsigned int Oid
Definition: postgres_ext.h:31
#define linitial_node(type, l)
Definition: pg_list.h:177
void(* callback)(void *arg)
Definition: elog.h:247
struct ErrorContextCallback * previous
Definition: elog.h:246
#define OidIsValid(objectId)
Definition: c.h:710
Oid TypenameGetTypidExtended(const char *typname, bool temp_ok)
Definition: namespace.c:785
#define lsecond(l)
Definition: pg_list.h:179
signed int int32
Definition: c.h:429
static struct pg_tm tm
Definition: localtime.c:102
char * schemaname
Definition: primnodes.h:67
ErrorContextCallback * error_context_stack
Definition: elog.c:93
char * relname
Definition: primnodes.h:68
void pfree(void *pointer)
Definition: mcxt.c:1169
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:161
bool typeByVal(Type t)
Definition: parse_type.c:611
#define linitial(l)
Definition: pg_list.h:174
#define ObjectIdGetDatum(X)
Definition: postgres.h:551
#define ERROR
Definition: elog.h:46
char * typeTypeName(Type t)
Definition: parse_type.c:621
bool setof
Definition: parsenodes.h:223
#define OidFunctionCall1(functionId, arg1)
Definition: fmgr.h:664
Datum stringTypeDatum(Type tp, char *string, int32 atttypmod)
Definition: parse_type.c:656
#define lfirst_node(type, lc)
Definition: pg_list.h:172
Definition: value.h:28
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
#define NoLock
Definition: lockdefs.h:34
static void pts_error_callback(void *arg)
Definition: parse_type.c:721
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:856
Oid collOid
Definition: parsenodes.h:685
#define CStringGetDatum(X)
Definition: postgres.h:622
char string[11]
Definition: preproc-type.c:46
static ListCell * list_head(const List *l)
Definition: pg_list.h:125
static void appendTypeNameToBuffer(const TypeName *typeName, StringInfo string)
Definition: parse_type.c:441
int location
Definition: parsenodes.h:688
Oid get_atttype(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:938
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:145
char * val
Definition: value.h:54
NameData typname
Definition: pg_type.h:41
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
#define unconstify(underlying_type, expr)
Definition: c.h:1243
Oid GetColumnDefCollation(ParseState *pstate, ColumnDef *coldef, Oid typeOid)
Definition: parse_type.c:542
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1127
Definition: value.h:45
char * NameListToString(List *names)
Definition: namespace.c:3147
uintptr_t Datum
Definition: postgres.h:411
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1175
List * typmods
Definition: parsenodes.h:225
TypeName * typeStringToTypeName(const char *str)
Definition: parse_type.c:735
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition: parse_type.c:310
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
Definition: parse_type.c:517
void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:782
#define InvalidOid
Definition: postgres_ext.h:36
union A_Const::ValUnion val
int16 attnum
Definition: pg_attribute.h:83
#define ereport(elevel,...)
Definition: elog.h:157
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3003
#define NOTICE
Definition: elog.h:37
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
Definition: syscache.h:195
#define lfourth(l)
Definition: pg_list.h:189
int location
Definition: parsenodes.h:228
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
static int list_length(const List *l)
Definition: pg_list.h:149
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int32 typemod
Definition: parsenodes.h:226
CollateClause * collClause
Definition: parsenodes.h:684
#define InvalidAttrNumber
Definition: attnum.h:23
int val
Definition: value.h:31
List * collname
Definition: parsenodes.h:332
List * arrayBounds
Definition: parsenodes.h:227
void * palloc(Size size)
Definition: mcxt.c:1062
int errmsg(const char *fmt,...)
Definition: elog.c:909
Oid typeTypeRelid(Type typ)
Definition: parse_type.c:632
#define elog(elevel,...)
Definition: elog.h:232
Oid getTypeIOParam(HeapTuple typeTuple)
Definition: lsyscache.c:2250
#define errcontext
Definition: elog.h:204
#define NameStr(name)
Definition: c.h:681
void * arg
#define lthird(l)
Definition: pg_list.h:184
List * raw_parser(const char *str, RawParseMode mode)
Definition: parser.c:42
Type typeidType(Oid id)
Definition: parse_type.c:580
Oid typeTypeId(Type tp)
Definition: parse_type.c:592
Oid get_collation_oid(List *name, bool missing_ok)
Definition: namespace.c:3646
Definition: pg_list.h:50
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1644
int16 AttrNumber
Definition: attnum.h:21
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:422
char * catalogname
Definition: primnodes.h:66
static int32 typenameTypeMod(ParseState *pstate, const TypeName *typeName, Type typ)
Definition: parse_type.c:332
List * fields
Definition: parsenodes.h:247
char * val
Definition: value.h:48
Oid LookupTypeNameOid(ParseState *pstate, const TypeName *typeName, bool missing_ok)
Definition: parse_type.c:232
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:291
bool pct_type
Definition: parsenodes.h:224