PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
define.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * define.c
4  * Support routines for various kinds of object creation.
5  *
6  *
7  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  *
11  * IDENTIFICATION
12  * src/backend/commands/define.c
13  *
14  * DESCRIPTION
15  * The "DefineFoo" routines take the parse tree and pick out the
16  * appropriate arguments/flags, passing the results to the
17  * corresponding "FooDefine" routines (in src/catalog) that do
18  * the actual catalog-munging. These routines also verify permission
19  * of the user to execute the command.
20  *
21  * NOTES
22  * These things must be defined and committed in the following order:
23  * "create function":
24  * input/output, recv/send procedures
25  * "create type":
26  * type
27  * "create operator":
28  * operators
29  *
30  *
31  *-------------------------------------------------------------------------
32  */
33 #include "postgres.h"
34 
35 #include <ctype.h>
36 #include <math.h>
37 
38 #include "catalog/namespace.h"
39 #include "commands/defrem.h"
40 #include "nodes/makefuncs.h"
41 #include "parser/parse_type.h"
42 #include "parser/scansup.h"
43 #include "utils/builtins.h"
44 
45 /*
46  * Extract a string value (otherwise uninterpreted) from a DefElem.
47  */
48 char *
50 {
51  if (def->arg == NULL)
52  ereport(ERROR,
53  (errcode(ERRCODE_SYNTAX_ERROR),
54  errmsg("%s requires a parameter",
55  def->defname)));
56  switch (nodeTag(def->arg))
57  {
58  case T_Integer:
59  return psprintf("%ld", (long) intVal(def->arg));
60  case T_Float:
61 
62  /*
63  * T_Float values are kept in string form, so this type cheat
64  * works (and doesn't risk losing precision)
65  */
66  return strVal(def->arg);
67  case T_String:
68  return strVal(def->arg);
69  case T_TypeName:
70  return TypeNameToString((TypeName *) def->arg);
71  case T_List:
72  return NameListToString((List *) def->arg);
73  case T_A_Star:
74  return pstrdup("*");
75  default:
76  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
77  }
78  return NULL; /* keep compiler quiet */
79 }
80 
81 /*
82  * Extract a numeric value (actually double) from a DefElem.
83  */
84 double
86 {
87  if (def->arg == NULL)
88  ereport(ERROR,
89  (errcode(ERRCODE_SYNTAX_ERROR),
90  errmsg("%s requires a numeric value",
91  def->defname)));
92  switch (nodeTag(def->arg))
93  {
94  case T_Integer:
95  return (double) intVal(def->arg);
96  case T_Float:
97  return floatVal(def->arg);
98  default:
99  ereport(ERROR,
100  (errcode(ERRCODE_SYNTAX_ERROR),
101  errmsg("%s requires a numeric value",
102  def->defname)));
103  }
104  return 0; /* keep compiler quiet */
105 }
106 
107 /*
108  * Extract a boolean value from a DefElem.
109  */
110 bool
112 {
113  /*
114  * If no parameter given, assume "true" is meant.
115  */
116  if (def->arg == NULL)
117  return true;
118 
119  /*
120  * Allow 0, 1, "true", "false", "on", "off"
121  */
122  switch (nodeTag(def->arg))
123  {
124  case T_Integer:
125  switch (intVal(def->arg))
126  {
127  case 0:
128  return false;
129  case 1:
130  return true;
131  default:
132  /* otherwise, error out below */
133  break;
134  }
135  break;
136  default:
137  {
138  char *sval = defGetString(def);
139 
140  /*
141  * The set of strings accepted here should match up with the
142  * grammar's opt_boolean production.
143  */
144  if (pg_strcasecmp(sval, "true") == 0)
145  return true;
146  if (pg_strcasecmp(sval, "false") == 0)
147  return false;
148  if (pg_strcasecmp(sval, "on") == 0)
149  return true;
150  if (pg_strcasecmp(sval, "off") == 0)
151  return false;
152  }
153  break;
154  }
155  ereport(ERROR,
156  (errcode(ERRCODE_SYNTAX_ERROR),
157  errmsg("%s requires a Boolean value",
158  def->defname)));
159  return false; /* keep compiler quiet */
160 }
161 
162 /*
163  * Extract an int32 value from a DefElem.
164  */
165 int32
167 {
168  if (def->arg == NULL)
169  ereport(ERROR,
170  (errcode(ERRCODE_SYNTAX_ERROR),
171  errmsg("%s requires an integer value",
172  def->defname)));
173  switch (nodeTag(def->arg))
174  {
175  case T_Integer:
176  return (int32) intVal(def->arg);
177  default:
178  ereport(ERROR,
179  (errcode(ERRCODE_SYNTAX_ERROR),
180  errmsg("%s requires an integer value",
181  def->defname)));
182  }
183  return 0; /* keep compiler quiet */
184 }
185 
186 /*
187  * Extract an int64 value from a DefElem.
188  */
189 int64
191 {
192  if (def->arg == NULL)
193  ereport(ERROR,
194  (errcode(ERRCODE_SYNTAX_ERROR),
195  errmsg("%s requires a numeric value",
196  def->defname)));
197  switch (nodeTag(def->arg))
198  {
199  case T_Integer:
200  return (int64) intVal(def->arg);
201  case T_Float:
202 
203  /*
204  * Values too large for int4 will be represented as Float
205  * constants by the lexer. Accept these if they are valid int8
206  * strings.
207  */
209  CStringGetDatum(strVal(def->arg))));
210  default:
211  ereport(ERROR,
212  (errcode(ERRCODE_SYNTAX_ERROR),
213  errmsg("%s requires a numeric value",
214  def->defname)));
215  }
216  return 0; /* keep compiler quiet */
217 }
218 
219 /*
220  * Extract a possibly-qualified name (as a List of Strings) from a DefElem.
221  */
222 List *
224 {
225  if (def->arg == NULL)
226  ereport(ERROR,
227  (errcode(ERRCODE_SYNTAX_ERROR),
228  errmsg("%s requires a parameter",
229  def->defname)));
230  switch (nodeTag(def->arg))
231  {
232  case T_TypeName:
233  return ((TypeName *) def->arg)->names;
234  case T_List:
235  return (List *) def->arg;
236  case T_String:
237  /* Allow quoted name for backwards compatibility */
238  return list_make1(def->arg);
239  default:
240  ereport(ERROR,
241  (errcode(ERRCODE_SYNTAX_ERROR),
242  errmsg("argument of %s must be a name",
243  def->defname)));
244  }
245  return NIL; /* keep compiler quiet */
246 }
247 
248 /*
249  * Extract a TypeName from a DefElem.
250  *
251  * Note: we do not accept a List arg here, because the parser will only
252  * return a bare List when the name looks like an operator name.
253  */
254 TypeName *
256 {
257  if (def->arg == NULL)
258  ereport(ERROR,
259  (errcode(ERRCODE_SYNTAX_ERROR),
260  errmsg("%s requires a parameter",
261  def->defname)));
262  switch (nodeTag(def->arg))
263  {
264  case T_TypeName:
265  return (TypeName *) def->arg;
266  case T_String:
267  /* Allow quoted typename for backwards compatibility */
269  default:
270  ereport(ERROR,
271  (errcode(ERRCODE_SYNTAX_ERROR),
272  errmsg("argument of %s must be a type name",
273  def->defname)));
274  }
275  return NULL; /* keep compiler quiet */
276 }
277 
278 /*
279  * Extract a type length indicator (either absolute bytes, or
280  * -1 for "variable") from a DefElem.
281  */
282 int
284 {
285  if (def->arg == NULL)
286  ereport(ERROR,
287  (errcode(ERRCODE_SYNTAX_ERROR),
288  errmsg("%s requires a parameter",
289  def->defname)));
290  switch (nodeTag(def->arg))
291  {
292  case T_Integer:
293  return intVal(def->arg);
294  case T_Float:
295  ereport(ERROR,
296  (errcode(ERRCODE_SYNTAX_ERROR),
297  errmsg("%s requires an integer value",
298  def->defname)));
299  break;
300  case T_String:
301  if (pg_strcasecmp(strVal(def->arg), "variable") == 0)
302  return -1; /* variable length */
303  break;
304  case T_TypeName:
305  /* cope if grammar chooses to believe "variable" is a typename */
307  "variable") == 0)
308  return -1; /* variable length */
309  break;
310  case T_List:
311  /* must be an operator name */
312  break;
313  default:
314  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
315  }
316  ereport(ERROR,
317  (errcode(ERRCODE_SYNTAX_ERROR),
318  errmsg("invalid argument for %s: \"%s\"",
319  def->defname, defGetString(def))));
320  return 0; /* keep compiler quiet */
321 }
322 
323 /*
324  * Extract a list of string values (otherwise uninterpreted) from a DefElem.
325  */
326 List *
328 {
329  ListCell *cell;
330 
331  if (def->arg == NULL)
332  ereport(ERROR,
333  (errcode(ERRCODE_SYNTAX_ERROR),
334  errmsg("%s requires a parameter",
335  def->defname)));
336  if (nodeTag(def->arg) != T_List)
337  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
338 
339  foreach(cell, (List *) def->arg)
340  {
341  Node *str = (Node *) lfirst(cell);
342 
343  if (!IsA(str, String))
344  elog(ERROR, "unexpected node type in name list: %d",
345  (int) nodeTag(str));
346  }
347 
348  return (List *) def->arg;
349 }
#define NIL
Definition: pg_list.h:69
#define IsA(nodeptr, _type_)
Definition: nodes.h:560
char * TypeNameToString(const TypeName *typeName)
Definition: parse_type.c:459
char * pstrdup(const char *in)
Definition: mcxt.c:1077
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
double defGetNumeric(DefElem *def)
Definition: define.c:85
Definition: nodes.h:509
#define strVal(v)
Definition: value.h:54
int32 defGetInt32(DefElem *def)
Definition: define.c:166
int errcode(int sqlerrcode)
Definition: elog.c:575
int64 defGetInt64(DefElem *def)
Definition: define.c:190
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:584
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
List * defGetStringList(DefElem *def)
Definition: define.c:327
signed int int32
Definition: c.h:256
int defGetTypeLength(DefElem *def)
Definition: define.c:283
#define list_make1(x1)
Definition: pg_list.h:139
bool defGetBoolean(DefElem *def)
Definition: define.c:111
TypeName * defGetTypeName(DefElem *def)
Definition: define.c:255
#define ERROR
Definition: elog.h:43
char * defGetString(DefElem *def)
Definition: define.c:49
#define DatumGetInt64(X)
Definition: postgres.h:613
#define CStringGetDatum(X)
Definition: postgres.h:584
#define floatVal(v)
Definition: value.h:53
#define ereport(elevel, rest)
Definition: elog.h:122
Definition: nodes.h:291
Node * arg
Definition: parsenodes.h:721
char * NameListToString(List *names)
Definition: namespace.c:3020
#define NULL
Definition: c.h:229
#define lfirst(lc)
Definition: pg_list.h:106
List * defGetQualifiedName(DefElem *def)
Definition: define.c:223
Datum int8in(PG_FUNCTION_ARGS)
Definition: int8.c:145
#define nodeTag(nodeptr)
Definition: nodes.h:514
Definition: nodes.h:283
#define intVal(v)
Definition: value.h:52
int errmsg(const char *fmt,...)
Definition: elog.c:797
TypeName * makeTypeNameFromNameList(List *names)
Definition: makefuncs.c:453
char * defname
Definition: parsenodes.h:720
#define elog
Definition: elog.h:219
Definition: pg_list.h:45