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-2022, 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,
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) intVal(&ac->val));
386  }
387  else if (IsA(&ac->val, Float))
388  {
389  /* we can just use the string representation directly. */
390  cstr = ac->val.fval.fval;
391  }
392  else if (IsA(&ac->val, String))
393  {
394  /* we can just use the string representation directly. */
395  cstr = strVal(&ac->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  arrtypmod = construct_array_builtin(datums, n, CSTRINGOID);
415 
416  /* arrange to report location if type's typmodin function fails */
417  setup_parser_errposition_callback(&pcbstate, pstate, typeName->location);
418 
419  result = DatumGetInt32(OidFunctionCall1(typmodin,
420  PointerGetDatum(arrtypmod)));
421 
423 
424  pfree(datums);
425  pfree(arrtypmod);
426 
427  return result;
428 }
429 
430 /*
431  * appendTypeNameToBuffer
432  * Append a string representing the name of a TypeName to a StringInfo.
433  * This is the shared guts of TypeNameToString and TypeNameListToString.
434  *
435  * NB: this must work on TypeNames that do not describe any actual type;
436  * it is mostly used for reporting lookup errors.
437  */
438 static void
440 {
441  if (typeName->names != NIL)
442  {
443  /* Emit possibly-qualified name as-is */
444  ListCell *l;
445 
446  foreach(l, typeName->names)
447  {
448  if (l != list_head(typeName->names))
449  appendStringInfoChar(string, '.');
450  appendStringInfoString(string, strVal(lfirst(l)));
451  }
452  }
453  else
454  {
455  /* Look up internally-specified type */
456  appendStringInfoString(string, format_type_be(typeName->typeOid));
457  }
458 
459  /*
460  * Add decoration as needed, but only for fields considered by
461  * LookupTypeName
462  */
463  if (typeName->pct_type)
464  appendStringInfoString(string, "%TYPE");
465 
466  if (typeName->arrayBounds != NIL)
467  appendStringInfoString(string, "[]");
468 }
469 
470 /*
471  * TypeNameToString
472  * Produce a string representing the name of a TypeName.
473  *
474  * NB: this must work on TypeNames that do not describe any actual type;
475  * it is mostly used for reporting lookup errors.
476  */
477 char *
478 TypeNameToString(const TypeName *typeName)
479 {
481 
482  initStringInfo(&string);
483  appendTypeNameToBuffer(typeName, &string);
484  return string.data;
485 }
486 
487 /*
488  * TypeNameListToString
489  * Produce a string representing the name(s) of a List of TypeNames
490  */
491 char *
493 {
495  ListCell *l;
496 
497  initStringInfo(&string);
498  foreach(l, typenames)
499  {
500  TypeName *typeName = lfirst_node(TypeName, l);
501 
502  if (l != list_head(typenames))
503  appendStringInfoChar(&string, ',');
504  appendTypeNameToBuffer(typeName, &string);
505  }
506  return string.data;
507 }
508 
509 /*
510  * LookupCollation
511  *
512  * Look up collation by name, return OID, with support for error location.
513  */
514 Oid
515 LookupCollation(ParseState *pstate, List *collnames, int location)
516 {
517  Oid colloid;
518  ParseCallbackState pcbstate;
519 
520  if (pstate)
521  setup_parser_errposition_callback(&pcbstate, pstate, location);
522 
523  colloid = get_collation_oid(collnames, false);
524 
525  if (pstate)
527 
528  return colloid;
529 }
530 
531 /*
532  * GetColumnDefCollation
533  *
534  * Get the collation to be used for a column being defined, given the
535  * ColumnDef node and the previously-determined column type OID.
536  *
537  * pstate is only used for error location purposes, and can be NULL.
538  */
539 Oid
540 GetColumnDefCollation(ParseState *pstate, ColumnDef *coldef, Oid typeOid)
541 {
542  Oid result;
543  Oid typcollation = get_typcollation(typeOid);
544  int location = coldef->location;
545 
546  if (coldef->collClause)
547  {
548  /* We have a raw COLLATE clause, so look up the collation */
549  location = coldef->collClause->location;
550  result = LookupCollation(pstate, coldef->collClause->collname,
551  location);
552  }
553  else if (OidIsValid(coldef->collOid))
554  {
555  /* Precooked collation spec, use that */
556  result = coldef->collOid;
557  }
558  else
559  {
560  /* Use the type's default collation if any */
561  result = typcollation;
562  }
563 
564  /* Complain if COLLATE is applied to an uncollatable type */
565  if (OidIsValid(result) && !OidIsValid(typcollation))
566  ereport(ERROR,
567  (errcode(ERRCODE_DATATYPE_MISMATCH),
568  errmsg("collations are not supported by type %s",
569  format_type_be(typeOid)),
570  parser_errposition(pstate, location)));
571 
572  return result;
573 }
574 
575 /* return a Type structure, given a type id */
576 /* NB: caller must ReleaseSysCache the type tuple when done with it */
577 Type
579 {
580  HeapTuple tup;
581 
583  if (!HeapTupleIsValid(tup))
584  elog(ERROR, "cache lookup failed for type %u", id);
585  return (Type) tup;
586 }
587 
588 /* given type (as type struct), return the type OID */
589 Oid
591 {
592  if (tp == NULL) /* probably useless */
593  elog(ERROR, "typeTypeId() called with NULL type struct");
594  return ((Form_pg_type) GETSTRUCT(tp))->oid;
595 }
596 
597 /* given type (as type struct), return the length of type */
598 int16
600 {
601  Form_pg_type typ;
602 
603  typ = (Form_pg_type) GETSTRUCT(t);
604  return typ->typlen;
605 }
606 
607 /* given type (as type struct), return its 'byval' attribute */
608 bool
610 {
611  Form_pg_type typ;
612 
613  typ = (Form_pg_type) GETSTRUCT(t);
614  return typ->typbyval;
615 }
616 
617 /* given type (as type struct), return the type's name */
618 char *
620 {
621  Form_pg_type typ;
622 
623  typ = (Form_pg_type) GETSTRUCT(t);
624  /* pstrdup here because result may need to outlive the syscache entry */
625  return pstrdup(NameStr(typ->typname));
626 }
627 
628 /* given type (as type struct), return its 'typrelid' attribute */
629 Oid
631 {
632  Form_pg_type typtup;
633 
634  typtup = (Form_pg_type) GETSTRUCT(typ);
635  return typtup->typrelid;
636 }
637 
638 /* given type (as type struct), return its 'typcollation' attribute */
639 Oid
641 {
642  Form_pg_type typtup;
643 
644  typtup = (Form_pg_type) GETSTRUCT(typ);
645  return typtup->typcollation;
646 }
647 
648 /*
649  * Given a type structure and a string, returns the internal representation
650  * of that string. The "string" can be NULL to perform conversion of a NULL
651  * (which might result in failure, if the input function rejects NULLs).
652  */
653 Datum
654 stringTypeDatum(Type tp, char *string, int32 atttypmod)
655 {
656  Form_pg_type typform = (Form_pg_type) GETSTRUCT(tp);
657  Oid typinput = typform->typinput;
658  Oid typioparam = getTypeIOParam(tp);
659 
660  return OidInputFunctionCall(typinput, string, typioparam, atttypmod);
661 }
662 
663 /*
664  * Given a typeid, return the type's typrelid (associated relation), if any.
665  * Returns InvalidOid if type is not a composite type.
666  */
667 Oid
669 {
670  HeapTuple typeTuple;
672  Oid result;
673 
674  typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
675  if (!HeapTupleIsValid(typeTuple))
676  elog(ERROR, "cache lookup failed for type %u", type_id);
677  type = (Form_pg_type) GETSTRUCT(typeTuple);
678  result = type->typrelid;
679  ReleaseSysCache(typeTuple);
680  return result;
681 }
682 
683 /*
684  * Given a typeid, return the type's typrelid (associated relation), if any.
685  * Returns InvalidOid if type is not a composite type or a domain over one.
686  * This is the same as typeidTypeRelid(getBaseType(type_id)), but faster.
687  */
688 Oid
690 {
691  HeapTuple typeTuple;
693  Oid result;
694 
695  for (;;)
696  {
697  typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
698  if (!HeapTupleIsValid(typeTuple))
699  elog(ERROR, "cache lookup failed for type %u", type_id);
700  type = (Form_pg_type) GETSTRUCT(typeTuple);
701  if (type->typtype != TYPTYPE_DOMAIN)
702  {
703  /* Not a domain, so done looking through domains */
704  break;
705  }
706  /* It is a domain, so examine the base type instead */
707  type_id = type->typbasetype;
708  ReleaseSysCache(typeTuple);
709  }
710  result = type->typrelid;
711  ReleaseSysCache(typeTuple);
712  return result;
713 }
714 
715 /*
716  * error context callback for parse failure during parseTypeString()
717  */
718 static void
720 {
721  const char *str = (const char *) arg;
722 
723  errcontext("invalid type name \"%s\"", str);
724 }
725 
726 /*
727  * Given a string that is supposed to be a SQL-compatible type declaration,
728  * such as "int4" or "integer" or "character varying(32)", parse
729  * the string and return the result as a TypeName.
730  * If the string cannot be parsed as a type, an error is raised.
731  */
732 TypeName *
734 {
735  List *raw_parsetree_list;
736  TypeName *typeName;
737  ErrorContextCallback ptserrcontext;
738 
739  /* make sure we give useful error for empty input */
740  if (strspn(str, " \t\n\r\f") == strlen(str))
741  goto fail;
742 
743  /*
744  * Setup error traceback support in case of ereport() during parse
745  */
746  ptserrcontext.callback = pts_error_callback;
747  ptserrcontext.arg = unconstify(char *, str);
748  ptserrcontext.previous = error_context_stack;
749  error_context_stack = &ptserrcontext;
750 
751  raw_parsetree_list = raw_parser(str, RAW_PARSE_TYPE_NAME);
752 
753  error_context_stack = ptserrcontext.previous;
754 
755  /* We should get back exactly one TypeName node. */
756  Assert(list_length(raw_parsetree_list) == 1);
757  typeName = linitial_node(TypeName, raw_parsetree_list);
758 
759  /* The grammar allows SETOF in TypeName, but we don't want that here. */
760  if (typeName->setof)
761  goto fail;
762 
763  return typeName;
764 
765 fail:
766  ereport(ERROR,
767  (errcode(ERRCODE_SYNTAX_ERROR),
768  errmsg("invalid type name \"%s\"", str)));
769  return NULL; /* keep compiler quiet */
770 }
771 
772 /*
773  * Given a string that is supposed to be a SQL-compatible type declaration,
774  * such as "int4" or "integer" or "character varying(32)", parse
775  * the string and convert it to a type OID and type modifier.
776  * If missing_ok is true, InvalidOid is returned rather than raising an error
777  * when the type name is not found.
778  */
779 void
780 parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok)
781 {
782  TypeName *typeName;
783  Type tup;
784 
785  typeName = typeStringToTypeName(str);
786 
787  tup = LookupTypeName(NULL, typeName, typmod_p, missing_ok);
788  if (tup == NULL)
789  {
790  if (!missing_ok)
791  ereport(ERROR,
792  (errcode(ERRCODE_UNDEFINED_OBJECT),
793  errmsg("type \"%s\" does not exist",
794  TypeNameToString(typeName)),
795  parser_errposition(NULL, typeName->location)));
796  *typeid_p = InvalidOid;
797  }
798  else
799  {
800  Form_pg_type typ = (Form_pg_type) GETSTRUCT(tup);
801 
802  if (!typ->typisdefined)
803  ereport(ERROR,
804  (errcode(ERRCODE_UNDEFINED_OBJECT),
805  errmsg("type \"%s\" is only a shell",
806  TypeNameToString(typeName)),
807  parser_errposition(NULL, typeName->location)));
808  *typeid_p = typ->oid;
809  ReleaseSysCache(tup);
810  }
811 }
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3338
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
List * raw_parser(const char *str, RawParseMode mode)
Definition: parser.c:42
#define NameStr(name)
Definition: c.h:682
#define unconstify(underlying_type, expr)
Definition: c.h:1181
signed short int16
Definition: c.h:429
signed int int32
Definition: c.h:430
#define OidIsValid(objectId)
Definition: c.h:711
ErrorContextCallback * error_context_stack
Definition: elog.c:94
int errcode(int sqlerrcode)
Definition: elog.c:695
int errmsg(const char *fmt,...)
Definition: elog.c:906
#define errcontext
Definition: elog.h:192
#define ERROR
Definition: elog.h:35
#define NOTICE
Definition: elog.h:31
#define ereport(elevel,...)
Definition: elog.h:145
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1630
#define OidFunctionCall1(functionId, arg1)
Definition: fmgr.h:680
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:649
Assert(fmt[strlen(fmt) - 1] !='\n')
static struct pg_tm tm
Definition: localtime.c:104
#define NoLock
Definition: lockdefs.h:34
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:857
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3014
Oid getTypeIOParam(HeapTuple typeTuple)
Definition: lsyscache.c:2261
Oid get_array_type(Oid typid)
Definition: lsyscache.c:2745
Oid get_atttype(Oid relid, AttrNumber attnum)
Definition: lsyscache.c:939
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:422
char * pstrdup(const char *in)
Definition: mcxt.c:1483
void pfree(void *pointer)
Definition: mcxt.c:1306
void * palloc(Size size)
Definition: mcxt.c:1199
Oid LookupExplicitNamespace(const char *nspname, bool missing_ok)
Definition: namespace.c:2936
void DeconstructQualifiedName(List *names, char **nspname_p, char **objname_p)
Definition: namespace.c:2852
Oid get_collation_oid(List *collname, bool missing_ok)
Definition: namespace.c:3644
Oid TypenameGetTypidExtended(const char *typname, bool temp_ok)
Definition: namespace.c:787
char * NameListToString(List *names)
Definition: namespace.c:3145
#define RangeVarGetRelid(relation, lockmode, missing_ok)
Definition: namespace.h:79
#define IsA(nodeptr, _type_)
Definition: nodes.h:162
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:160
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:144
static void appendTypeNameToBuffer(const TypeName *typeName, StringInfo string)
Definition: parse_type.c:439
Oid typeTypeRelid(Type typ)
Definition: parse_type.c:630
Oid typeOrDomainTypeRelid(Oid type_id)
Definition: parse_type.c:689
Type typeidType(Oid id)
Definition: parse_type.c:578
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
Definition: parse_type.c:515
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:640
void typenameTypeIdAndMod(ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
Definition: parse_type.c:310
char * TypeNameListToString(List *typenames)
Definition: parse_type.c:492
Type LookupTypeName(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:38
Oid typeidTypeRelid(Oid type_id)
Definition: parse_type.c:668
void parseTypeString(const char *str, Oid *typeid_p, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:780
Oid GetColumnDefCollation(ParseState *pstate, ColumnDef *coldef, Oid typeOid)
Definition: parse_type.c:540
static void pts_error_callback(void *arg)
Definition: parse_type.c:719
char * TypeNameToString(const TypeName *typeName)
Definition: parse_type.c:478
TypeName * typeStringToTypeName(const char *str)
Definition: parse_type.c:733
Datum stringTypeDatum(Type tp, char *string, int32 atttypmod)
Definition: parse_type.c:654
Type typenameType(ParseState *pstate, const TypeName *typeName, int32 *typmod_p)
Definition: parse_type.c:264
static int32 typenameTypeMod(ParseState *pstate, const TypeName *typeName, Type typ)
Definition: parse_type.c:332
bool typeByVal(Type t)
Definition: parse_type.c:609
Oid typeTypeId(Type tp)
Definition: parse_type.c:590
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:291
int16 typeLen(Type t)
Definition: parse_type.c:599
Oid LookupTypeNameOid(ParseState *pstate, const TypeName *typeName, bool missing_ok)
Definition: parse_type.c:232
char * typeTypeName(Type t)
Definition: parse_type.c:619
@ RAW_PARSE_TYPE_NAME
Definition: parser.h:40
int16 attnum
Definition: pg_attribute.h:83
void * arg
#define lfirst(lc)
Definition: pg_list.h:170
#define lfirst_node(type, lc)
Definition: pg_list.h:174
static int list_length(const List *l)
Definition: pg_list.h:150
#define linitial_node(type, l)
Definition: pg_list.h:179
#define NIL
Definition: pg_list.h:66
#define lthird(l)
Definition: pg_list.h:186
static ListCell * list_head(const List *l)
Definition: pg_list.h:126
#define linitial(l)
Definition: pg_list.h:176
#define lsecond(l)
Definition: pg_list.h:181
#define lfourth(l)
Definition: pg_list.h:191
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
NameData typname
Definition: pg_type.h:41
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:670
uintptr_t Datum
Definition: postgres.h:412
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:600
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:698
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:550
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
char string[11]
Definition: preproc-type.c:52
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59
union ValUnion val
Definition: parsenodes.h:325
List * collname
Definition: parsenodes.h:348
CollateClause * collClause
Definition: parsenodes.h:701
int location
Definition: parsenodes.h:705
Oid collOid
Definition: parsenodes.h:702
List * fields
Definition: parsenodes.h:257
struct ErrorContextCallback * previous
Definition: elog.h:234
void(* callback)(void *arg)
Definition: elog.h:235
Definition: value.h:48
char * fval
Definition: value.h:52
Definition: value.h:29
Definition: pg_list.h:52
Definition: nodes.h:112
char * relname
Definition: primnodes.h:77
char * schemaname
Definition: primnodes.h:74
Definition: value.h:64
bool setof
Definition: parsenodes.h:233
Oid typeOid
Definition: parsenodes.h:232
bool pct_type
Definition: parsenodes.h:234
List * names
Definition: parsenodes.h:231
List * arrayBounds
Definition: parsenodes.h:237
int32 typemod
Definition: parsenodes.h:236
int location
Definition: parsenodes.h:238
List * typmods
Definition: parsenodes.h:235
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1221
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1173
@ TYPEOID
Definition: syscache.h:114
@ TYPENAMENSP
Definition: syscache.h:113
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
Definition: syscache.h:199
Float fval
Definition: parsenodes.h:314
#define intVal(v)
Definition: value.h:79
#define strVal(v)
Definition: value.h:82