PostgreSQL Source Code  git master
parse_type.h File Reference
#include "access/htup.h"
#include "parser/parse_node.h"
Include dependency graph for parse_type.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define ISCOMPLEX(typeid)   (typeOrDomainTypeRelid(typeid) != InvalidOid)
 

Typedefs

typedef HeapTuple Type
 

Functions

Type LookupTypeName (ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
 
Type LookupTypeNameExtended (ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool temp_ok, bool missing_ok)
 
Oid LookupTypeNameOid (ParseState *pstate, const TypeName *typeName, bool missing_ok)
 
Type typenameType (ParseState *pstate, const TypeName *typeName, int32 *typmod_p)
 
Oid typenameTypeId (ParseState *pstate, const TypeName *typeName)
 
void typenameTypeIdAndMod (ParseState *pstate, const TypeName *typeName, Oid *typeid_p, int32 *typmod_p)
 
char * TypeNameToString (const TypeName *typeName)
 
char * TypeNameListToString (List *typenames)
 
Oid LookupCollation (ParseState *pstate, List *collnames, int location)
 
Oid GetColumnDefCollation (ParseState *pstate, ColumnDef *coldef, Oid typeOid)
 
Type typeidType (Oid id)
 
Oid typeTypeId (Type tp)
 
int16 typeLen (Type t)
 
bool typeByVal (Type t)
 
char * typeTypeName (Type t)
 
Oid typeTypeRelid (Type typ)
 
Oid typeTypeCollation (Type typ)
 
Datum stringTypeDatum (Type tp, char *string, int32 atttypmod)
 
Oid typeidTypeRelid (Oid type_id)
 
Oid typeOrDomainTypeRelid (Oid type_id)
 
TypeNametypeStringToTypeName (const char *str, Node *escontext)
 
bool parseTypeString (const char *str, Oid *typeid_p, int32 *typmod_p, Node *escontext)
 

Macro Definition Documentation

◆ ISCOMPLEX

#define ISCOMPLEX (   typeid)    (typeOrDomainTypeRelid(typeid) != InvalidOid)

Definition at line 59 of file parse_type.h.

Typedef Documentation

◆ Type

typedef HeapTuple Type

Definition at line 20 of file parse_type.h.

Function Documentation

◆ GetColumnDefCollation()

Oid GetColumnDefCollation ( ParseState pstate,
ColumnDef coldef,
Oid  typeOid 
)

Definition at line 540 of file parse_type.c.

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 }
#define OidIsValid(objectId)
Definition: c.h:759
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3014
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
Oid LookupCollation(ParseState *pstate, List *collnames, int location)
Definition: parse_type.c:515
unsigned int Oid
Definition: postgres_ext.h:31
List * collname
Definition: parsenodes.h:383
CollateClause * collClause
Definition: parsenodes.h:736
int location
Definition: parsenodes.h:740
Oid collOid
Definition: parsenodes.h:737

References ColumnDef::collClause, CollateClause::collname, ColumnDef::collOid, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_typcollation(), CollateClause::location, ColumnDef::location, LookupCollation(), OidIsValid, and parser_errposition().

Referenced by addRangeTableEntryForFunction(), ATExecAddColumn(), ATExecAlterColumnType(), ATPrepAlterColumnType(), BuildDescForRelation(), and MergeAttributes().

◆ LookupCollation()

Oid LookupCollation ( ParseState pstate,
List collnames,
int  location 
)

Definition at line 515 of file parse_type.c.

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 }
Oid get_collation_oid(List *collname, bool missing_ok)
Definition: namespace.c:3644
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:160
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:144

References cancel_parser_errposition_callback(), get_collation_oid(), and setup_parser_errposition_callback().

Referenced by GetColumnDefCollation(), resolve_unique_index_expr(), transformCollateClause(), and transformColumnType().

◆ LookupTypeName()

Type LookupTypeName ( ParseState pstate,
const TypeName typeName,
int32 typmod_p,
bool  missing_ok 
)

Definition at line 38 of file parse_type.c.

40 {
41  return LookupTypeNameExtended(pstate,
42  typeName, typmod_p, true, missing_ok);
43 }
Type LookupTypeNameExtended(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool temp_ok, bool missing_ok)
Definition: parse_type.c:73

References LookupTypeNameExtended().

Referenced by AlterTypeOwner(), compute_return_type(), get_object_address_type(), interpret_function_parameter_list(), LookupTypeNameOid(), parseTypeString(), plpgsql_parse_wordtype(), and typenameType().

◆ LookupTypeNameExtended()

Type LookupTypeNameExtended ( ParseState pstate,
const TypeName typeName,
int32 typmod_p,
bool  temp_ok,
bool  missing_ok 
)

Definition at line 73 of file parse_type.c.

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 }
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
signed int int32
Definition: c.h:478
#define NOTICE
Definition: elog.h:35
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
Assert(fmt[strlen(fmt) - 1] !='\n')
#define NoLock
Definition: lockdefs.h:34
AttrNumber get_attnum(Oid relid, const char *attname)
Definition: lsyscache.c:857
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:424
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 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
char * TypeNameToString(const TypeName *typeName)
Definition: parse_type.c:478
static int32 typenameTypeMod(ParseState *pstate, const TypeName *typeName, Type typ)
Definition: parse_type.c:332
int16 attnum
Definition: pg_attribute.h:83
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define lthird(l)
Definition: pg_list.h:188
#define linitial(l)
Definition: pg_list.h:178
#define lsecond(l)
Definition: pg_list.h:183
#define lfourth(l)
Definition: pg_list.h:193
NameData typname
Definition: pg_type.h:41
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define InvalidOid
Definition: postgres_ext.h:36
char * relname
Definition: primnodes.h:74
char * catalogname
Definition: primnodes.h:68
char * schemaname
Definition: primnodes.h:71
Oid typeOid
Definition: parsenodes.h:267
bool pct_type
Definition: parsenodes.h:269
List * names
Definition: parsenodes.h:266
List * arrayBounds
Definition: parsenodes.h:272
int location
Definition: parsenodes.h:273
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:817
@ TYPEOID
Definition: syscache.h:114
@ TYPENAMENSP
Definition: syscache.h:113
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
Definition: syscache.h:199
#define strVal(v)
Definition: value.h:82

References TypeName::arrayBounds, Assert(), attnum, cancel_parser_errposition_callback(), RangeVar::catalogname, DeconstructQualifiedName(), elog(), ereport, errcode(), errmsg(), ERROR, format_type_be(), get_array_type(), get_attnum(), get_atttype(), GetSysCacheOid2, HeapTupleIsValid, InvalidAttrNumber, InvalidOid, lfourth, linitial, list_length(), TypeName::location, LookupExplicitNamespace(), lsecond, lthird, makeRangeVar(), NameListToString(), TypeName::names, NIL, NoLock, NOTICE, ObjectIdGetDatum(), OidIsValid, parser_errposition(), TypeName::pct_type, PointerGetDatum(), RangeVarGetRelid, RangeVar::relname, RangeVar::schemaname, SearchSysCache1(), setup_parser_errposition_callback(), strVal, TypenameGetTypidExtended(), TYPENAMENSP, TypeNameToString(), typenameTypeMod(), TypeName::typeOid, TYPEOID, and typname.

Referenced by FuncNameAsType(), and LookupTypeName().

◆ LookupTypeNameOid()

Oid LookupTypeNameOid ( ParseState pstate,
const TypeName typeName,
bool  missing_ok 
)

Definition at line 232 of file parse_type.c.

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 }
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
Type LookupTypeName(ParseState *pstate, const TypeName *typeName, int32 *typmod_p, bool missing_ok)
Definition: parse_type.c:38
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:865

References ereport, errcode(), errmsg(), ERROR, GETSTRUCT, InvalidOid, TypeName::location, LookupTypeName(), parser_errposition(), ReleaseSysCache(), and TypeNameToString().

Referenced by get_object_address(), LookupFuncWithArgs(), LookupOperWithArgs(), and type_in_list_does_not_exist_skipping().

◆ parseTypeString()

bool parseTypeString ( const char *  str,
Oid typeid_p,
int32 typmod_p,
Node escontext 
)

Definition at line 785 of file parse_type.c.

787 {
788  TypeName *typeName;
789  Type tup;
790 
791  typeName = typeStringToTypeName(str, escontext);
792  if (typeName == NULL)
793  return false;
794 
795  tup = LookupTypeName(NULL, typeName, typmod_p,
796  (escontext && IsA(escontext, ErrorSaveContext)));
797  if (tup == NULL)
798  {
799  ereturn(escontext, false,
800  (errcode(ERRCODE_UNDEFINED_OBJECT),
801  errmsg("type \"%s\" does not exist",
802  TypeNameToString(typeName))));
803  }
804  else
805  {
806  Form_pg_type typ = (Form_pg_type) GETSTRUCT(tup);
807 
808  if (!typ->typisdefined)
809  {
810  ReleaseSysCache(tup);
811  ereturn(escontext, false,
812  (errcode(ERRCODE_UNDEFINED_OBJECT),
813  errmsg("type \"%s\" is only a shell",
814  TypeNameToString(typeName))));
815  }
816  *typeid_p = typ->oid;
817  ReleaseSysCache(tup);
818  }
819 
820  return true;
821 }
#define ereturn(context, dummy_value,...)
Definition: elog.h:276
#define IsA(nodeptr, _type_)
Definition: nodes.h:179
TypeName * typeStringToTypeName(const char *str, Node *escontext)
Definition: parse_type.c:738

References ereturn, errcode(), errmsg(), GETSTRUCT, IsA, LookupTypeName(), ReleaseSysCache(), generate_unaccent_rules::str, TypeNameToString(), and typeStringToTypeName().

Referenced by parseNameAndArgTypes(), pg_input_is_valid_common(), plperl_spi_prepare(), pltcl_SPI_prepare(), PLy_spi_prepare(), and regtypein().

◆ stringTypeDatum()

Datum stringTypeDatum ( Type  tp,
char *  string,
int32  atttypmod 
)

Definition at line 654 of file parse_type.c.

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 }
Datum OidInputFunctionCall(Oid functionId, char *str, Oid typioparam, int32 typmod)
Definition: fmgr.c:1741
Oid getTypeIOParam(HeapTuple typeTuple)
Definition: lsyscache.c:2261

References GETSTRUCT, getTypeIOParam(), and OidInputFunctionCall().

Referenced by coerce_type().

◆ typeByVal()

bool typeByVal ( Type  t)

Definition at line 609 of file parse_type.c.

610 {
611  Form_pg_type typ;
612 
613  typ = (Form_pg_type) GETSTRUCT(t);
614  return typ->typbyval;
615 }

References GETSTRUCT.

Referenced by coerce_type().

◆ typeidType()

Type typeidType ( Oid  id)

Definition at line 578 of file parse_type.c.

579 {
580  HeapTuple tup;
581 
583  if (!HeapTupleIsValid(tup))
584  elog(ERROR, "cache lookup failed for type %u", id);
585  return (Type) tup;
586 }

References elog(), ERROR, HeapTupleIsValid, ObjectIdGetDatum(), SearchSysCache1(), and TYPEOID.

Referenced by coerce_type(), and find_typmod_coercion_function().

◆ typeidTypeRelid()

Oid typeidTypeRelid ( Oid  type_id)

Definition at line 668 of file parse_type.c.

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 }

References elog(), ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), generate_unaccent_rules::type, and TYPEOID.

Referenced by transformAssignmentIndirection(), and typeInheritsFrom().

◆ typeLen()

int16 typeLen ( Type  t)

Definition at line 599 of file parse_type.c.

600 {
601  Form_pg_type typ;
602 
603  typ = (Form_pg_type) GETSTRUCT(t);
604  return typ->typlen;
605 }

References GETSTRUCT.

Referenced by coerce_type().

◆ TypeNameListToString()

char* TypeNameListToString ( List typenames)

Definition at line 492 of file parse_type.c.

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 }
static void appendTypeNameToBuffer(const TypeName *typeName, StringInfo string)
Definition: parse_type.c:439
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
char string[11]
Definition: preproc-type.c:52
void appendStringInfoChar(StringInfo str, char ch)
Definition: stringinfo.c:188
void initStringInfo(StringInfo str)
Definition: stringinfo.c:59

References appendStringInfoChar(), appendTypeNameToBuffer(), initStringInfo(), lfirst_node, and list_head().

Referenced by does_not_exist_skipping().

◆ TypeNameToString()

◆ typenameType()

Type typenameType ( ParseState pstate,
const TypeName typeName,
int32 typmod_p 
)

Definition at line 264 of file parse_type.c.

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 }

References ereport, errcode(), errmsg(), ERROR, GETSTRUCT, TypeName::location, LookupTypeName(), parser_errposition(), and TypeNameToString().

Referenced by AlterType(), ATExecAddColumn(), ATExecAddOf(), ATExecAlterColumnType(), DefineDomain(), DefineType(), transformColumnDefinition(), transformColumnType(), transformOfType(), typenameTypeId(), and typenameTypeIdAndMod().

◆ typenameTypeId()

Oid typenameTypeId ( ParseState pstate,
const TypeName typeName 
)

◆ typenameTypeIdAndMod()

void typenameTypeIdAndMod ( ParseState pstate,
const TypeName typeName,
Oid typeid_p,
int32 typmod_p 
)

◆ typeOrDomainTypeRelid()

Oid typeOrDomainTypeRelid ( Oid  type_id)

Definition at line 689 of file parse_type.c.

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 }

References elog(), ERROR, GETSTRUCT, HeapTupleIsValid, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), generate_unaccent_rules::type, and TYPEOID.

Referenced by typeInheritsFrom(), and typeIsOfTypedTable().

◆ typeStringToTypeName()

TypeName* typeStringToTypeName ( const char *  str,
Node escontext 
)

Definition at line 738 of file parse_type.c.

739 {
740  List *raw_parsetree_list;
741  TypeName *typeName;
742  ErrorContextCallback ptserrcontext;
743 
744  /* make sure we give useful error for empty input */
745  if (strspn(str, " \t\n\r\f") == strlen(str))
746  goto fail;
747 
748  /*
749  * Setup error traceback support in case of ereport() during parse
750  */
751  ptserrcontext.callback = pts_error_callback;
752  ptserrcontext.arg = unconstify(char *, str);
753  ptserrcontext.previous = error_context_stack;
754  error_context_stack = &ptserrcontext;
755 
756  raw_parsetree_list = raw_parser(str, RAW_PARSE_TYPE_NAME);
757 
758  error_context_stack = ptserrcontext.previous;
759 
760  /* We should get back exactly one TypeName node. */
761  Assert(list_length(raw_parsetree_list) == 1);
762  typeName = linitial_node(TypeName, raw_parsetree_list);
763 
764  /* The grammar allows SETOF in TypeName, but we don't want that here. */
765  if (typeName->setof)
766  goto fail;
767 
768  return typeName;
769 
770 fail:
771  ereturn(escontext, NULL,
772  (errcode(ERRCODE_SYNTAX_ERROR),
773  errmsg("invalid type name \"%s\"", str)));
774 }
List * raw_parser(const char *str, RawParseMode mode)
Definition: parser.c:42
#define unconstify(underlying_type, expr)
Definition: c.h:1232
ErrorContextCallback * error_context_stack
Definition: elog.c:95
static void pts_error_callback(void *arg)
Definition: parse_type.c:719
@ RAW_PARSE_TYPE_NAME
Definition: parser.h:40
#define linitial_node(type, l)
Definition: pg_list.h:181
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296
Definition: pg_list.h:54
bool setof
Definition: parsenodes.h:268

References ErrorContextCallback::arg, Assert(), ErrorContextCallback::callback, ereturn, errcode(), errmsg(), error_context_stack, linitial_node, list_length(), ErrorContextCallback::previous, pts_error_callback(), RAW_PARSE_TYPE_NAME, raw_parser(), TypeName::setof, generate_unaccent_rules::str, and unconstify.

Referenced by parseTypeString(), and pg_get_object_address().

◆ typeTypeCollation()

Oid typeTypeCollation ( Type  typ)

Definition at line 640 of file parse_type.c.

641 {
642  Form_pg_type typtup;
643 
644  typtup = (Form_pg_type) GETSTRUCT(typ);
645  return typtup->typcollation;
646 }

References GETSTRUCT.

Referenced by coerce_type().

◆ typeTypeId()

Oid typeTypeId ( Type  tp)

Definition at line 590 of file parse_type.c.

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 }

References elog(), ERROR, and GETSTRUCT.

Referenced by AlterType(), AlterTypeOwner(), compute_return_type(), FuncNameAsType(), get_object_address_type(), and interpret_function_parameter_list().

◆ typeTypeName()

char* typeTypeName ( Type  t)

Definition at line 619 of file parse_type.c.

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 }
#define NameStr(name)
Definition: c.h:730
char * pstrdup(const char *in)
Definition: mcxt.c:1624

References GETSTRUCT, NameStr, and pstrdup().

Referenced by coerce_type().

◆ typeTypeRelid()

Oid typeTypeRelid ( Type  typ)

Definition at line 630 of file parse_type.c.

631 {
632  Form_pg_type typtup;
633 
634  typtup = (Form_pg_type) GETSTRUCT(typ);
635  return typtup->typrelid;
636 }

References GETSTRUCT.

Referenced by FuncNameAsType().