1 /*-------------------------------------------------------------------------
2 *
3 * makefuncs.c
4 * creator functions for primitive nodes. The functions here are for
5 * the most frequently created nodes.
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/nodes/makefuncs.c
13 *
14 *-------------------------------------------------------------------------
15 */
16 #include "postgres.h"
17
18 #include "catalog/pg_class.h"
19 #include "catalog/pg_type.h"
20 #include "fmgr.h"
21 #include "nodes/makefuncs.h"
22 #include "nodes/nodeFuncs.h"
23 #include "utils/lsyscache.h"
24
25
26 /*
27 * makeA_Expr -
28 * makes an A_Expr node
29 */
30 A_Expr *
makeA_Expr(A_Expr_Kind kind,List * name,Node * lexpr,Node * rexpr,int location)31 makeA_Expr(A_Expr_Kind kind, List *name,
32 Node *lexpr, Node *rexpr, int location)
33 {
34 A_Expr *a = makeNode(A_Expr);
35
36 a->kind = kind;
37 a->name = name;
38 a->lexpr = lexpr;
39 a->rexpr = rexpr;
40 a->location = location;
41 return a;
42 }
43
44 /*
45 * makeSimpleA_Expr -
46 * As above, given a simple (unqualified) operator name
47 */
48 A_Expr *
makeSimpleA_Expr(A_Expr_Kind kind,char * name,Node * lexpr,Node * rexpr,int location)49 makeSimpleA_Expr(A_Expr_Kind kind, char *name,
50 Node *lexpr, Node *rexpr, int location)
51 {
52 A_Expr *a = makeNode(A_Expr);
53
54 a->kind = kind;
55 a->name = list_make1(makeString((char *) name));
56 a->lexpr = lexpr;
57 a->rexpr = rexpr;
58 a->location = location;
59 return a;
60 }
61
62 /*
63 * makeVar -
64 * creates a Var node
65 */
66 Var *
makeVar(Index varno,AttrNumber varattno,Oid vartype,int32 vartypmod,Oid varcollid,Index varlevelsup)67 makeVar(Index varno,
68 AttrNumber varattno,
69 Oid vartype,
70 int32 vartypmod,
71 Oid varcollid,
72 Index varlevelsup)
73 {
74 Var *var = makeNode(Var);
75
76 var->varno = varno;
77 var->varattno = varattno;
78 var->vartype = vartype;
79 var->vartypmod = vartypmod;
80 var->varcollid = varcollid;
81 var->varlevelsup = varlevelsup;
82
83 /*
84 * Since few if any routines ever create Var nodes with varnoold/varoattno
85 * different from varno/varattno, we don't provide separate arguments for
86 * them, but just initialize them to the given varno/varattno. This
87 * reduces code clutter and chance of error for most callers.
88 */
89 var->varnoold = varno;
90 var->varoattno = varattno;
91
92 /* Likewise, we just set location to "unknown" here */
93 var->location = -1;
94
95 return var;
96 }
97
98 /*
99 * makeVarFromTargetEntry -
100 * convenience function to create a same-level Var node from a
101 * TargetEntry
102 */
103 Var *
makeVarFromTargetEntry(Index varno,TargetEntry * tle)104 makeVarFromTargetEntry(Index varno,
105 TargetEntry *tle)
106 {
107 return makeVar(varno,
108 tle->resno,
109 exprType((Node *) tle->expr),
110 exprTypmod((Node *) tle->expr),
111 exprCollation((Node *) tle->expr),
112 0);
113 }
114
115 /*
116 * makeWholeRowVar -
117 * creates a Var node representing a whole row of the specified RTE
118 *
119 * A whole-row reference is a Var with varno set to the correct range
120 * table entry, and varattno == 0 to signal that it references the whole
121 * tuple. (Use of zero here is unclean, since it could easily be confused
122 * with error cases, but it's not worth changing now.) The vartype indicates
123 * a rowtype; either a named composite type, or RECORD. This function
124 * encapsulates the logic for determining the correct rowtype OID to use.
125 *
126 * If allowScalar is true, then for the case where the RTE is a single function
127 * returning a non-composite result type, we produce a normal Var referencing
128 * the function's result directly, instead of the single-column composite
129 * value that the whole-row notation might otherwise suggest.
130 */
131 Var *
makeWholeRowVar(RangeTblEntry * rte,Index varno,Index varlevelsup,bool allowScalar)132 makeWholeRowVar(RangeTblEntry *rte,
133 Index varno,
134 Index varlevelsup,
135 bool allowScalar)
136 {
137 Var *result;
138 Oid toid;
139 Node *fexpr;
140
141 switch (rte->rtekind)
142 {
143 case RTE_RELATION:
144 /* relation: the rowtype is a named composite type */
145 toid = get_rel_type_id(rte->relid);
146 if (!OidIsValid(toid))
147 elog(ERROR, "could not find type OID for relation %u",
148 rte->relid);
149 result = makeVar(varno,
150 InvalidAttrNumber,
151 toid,
152 -1,
153 InvalidOid,
154 varlevelsup);
155 break;
156
157 case RTE_FUNCTION:
158
159 /*
160 * If there's more than one function, or ordinality is requested,
161 * force a RECORD result, since there's certainly more than one
162 * column involved and it can't be a known named type.
163 */
164 if (rte->funcordinality || list_length(rte->functions) != 1)
165 {
166 /* always produces an anonymous RECORD result */
167 result = makeVar(varno,
168 InvalidAttrNumber,
169 RECORDOID,
170 -1,
171 InvalidOid,
172 varlevelsup);
173 break;
174 }
175
176 fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
177 toid = exprType(fexpr);
178 if (type_is_rowtype(toid))
179 {
180 /* func returns composite; same as relation case */
181 result = makeVar(varno,
182 InvalidAttrNumber,
183 toid,
184 -1,
185 InvalidOid,
186 varlevelsup);
187 }
188 else if (allowScalar)
189 {
190 /* func returns scalar; just return its output as-is */
191 result = makeVar(varno,
192 1,
193 toid,
194 -1,
195 exprCollation(fexpr),
196 varlevelsup);
197 }
198 else
199 {
200 /* func returns scalar, but we want a composite result */
201 result = makeVar(varno,
202 InvalidAttrNumber,
203 RECORDOID,
204 -1,
205 InvalidOid,
206 varlevelsup);
207 }
208 break;
209
210 default:
211
212 /*
213 * RTE is a join, subselect, tablefunc, or VALUES. We represent
214 * this as a whole-row Var of RECORD type. (Note that in most
215 * cases the Var will be expanded to a RowExpr during planning,
216 * but that is not our concern here.)
217 */
218 result = makeVar(varno,
219 InvalidAttrNumber,
220 RECORDOID,
221 -1,
222 InvalidOid,
223 varlevelsup);
224 break;
225 }
226
227 return result;
228 }
229
230 /*
231 * makeTargetEntry -
232 * creates a TargetEntry node
233 */
234 TargetEntry *
makeTargetEntry(Expr * expr,AttrNumber resno,char * resname,bool resjunk)235 makeTargetEntry(Expr *expr,
236 AttrNumber resno,
237 char *resname,
238 bool resjunk)
239 {
240 TargetEntry *tle = makeNode(TargetEntry);
241
242 tle->expr = expr;
243 tle->resno = resno;
244 tle->resname = resname;
245
246 /*
247 * We always set these fields to 0. If the caller wants to change them he
248 * must do so explicitly. Few callers do that, so omitting these
249 * arguments reduces the chance of error.
250 */
251 tle->ressortgroupref = 0;
252 tle->resorigtbl = InvalidOid;
253 tle->resorigcol = 0;
254
255 tle->resjunk = resjunk;
256
257 return tle;
258 }
259
260 /*
261 * flatCopyTargetEntry -
262 * duplicate a TargetEntry, but don't copy substructure
263 *
264 * This is commonly used when we just want to modify the resno or substitute
265 * a new expression.
266 */
267 TargetEntry *
flatCopyTargetEntry(TargetEntry * src_tle)268 flatCopyTargetEntry(TargetEntry *src_tle)
269 {
270 TargetEntry *tle = makeNode(TargetEntry);
271
272 Assert(IsA(src_tle, TargetEntry));
273 memcpy(tle, src_tle, sizeof(TargetEntry));
274 return tle;
275 }
276
277 /*
278 * makeFromExpr -
279 * creates a FromExpr node
280 */
281 FromExpr *
makeFromExpr(List * fromlist,Node * quals)282 makeFromExpr(List *fromlist, Node *quals)
283 {
284 FromExpr *f = makeNode(FromExpr);
285
286 f->fromlist = fromlist;
287 f->quals = quals;
288 return f;
289 }
290
291 /*
292 * makeConst -
293 * creates a Const node
294 */
295 Const *
makeConst(Oid consttype,int32 consttypmod,Oid constcollid,int constlen,Datum constvalue,bool constisnull,bool constbyval)296 makeConst(Oid consttype,
297 int32 consttypmod,
298 Oid constcollid,
299 int constlen,
300 Datum constvalue,
301 bool constisnull,
302 bool constbyval)
303 {
304 Const *cnst = makeNode(Const);
305
306 /*
307 * If it's a varlena value, force it to be in non-expanded (non-toasted)
308 * format; this avoids any possible dependency on external values and
309 * improves consistency of representation, which is important for equal().
310 */
311 if (!constisnull && constlen == -1)
312 constvalue = PointerGetDatum(PG_DETOAST_DATUM(constvalue));
313
314 cnst->consttype = consttype;
315 cnst->consttypmod = consttypmod;
316 cnst->constcollid = constcollid;
317 cnst->constlen = constlen;
318 cnst->constvalue = constvalue;
319 cnst->constisnull = constisnull;
320 cnst->constbyval = constbyval;
321 cnst->location = -1; /* "unknown" */
322
323 return cnst;
324 }
325
326 /*
327 * makeNullConst -
328 * creates a Const node representing a NULL of the specified type/typmod
329 *
330 * This is a convenience routine that just saves a lookup of the type's
331 * storage properties.
332 */
333 Const *
makeNullConst(Oid consttype,int32 consttypmod,Oid constcollid)334 makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
335 {
336 int16 typLen;
337 bool typByVal;
338
339 get_typlenbyval(consttype, &typLen, &typByVal);
340 return makeConst(consttype,
341 consttypmod,
342 constcollid,
343 (int) typLen,
344 (Datum) 0,
345 true,
346 typByVal);
347 }
348
349 /*
350 * makeBoolConst -
351 * creates a Const node representing a boolean value (can be NULL too)
352 */
353 Node *
makeBoolConst(bool value,bool isnull)354 makeBoolConst(bool value, bool isnull)
355 {
356 /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
357 return (Node *) makeConst(BOOLOID, -1, InvalidOid, 1,
358 BoolGetDatum(value), isnull, true);
359 }
360
361 /*
362 * makeBoolExpr -
363 * creates a BoolExpr node
364 */
365 Expr *
makeBoolExpr(BoolExprType boolop,List * args,int location)366 makeBoolExpr(BoolExprType boolop, List *args, int location)
367 {
368 BoolExpr *b = makeNode(BoolExpr);
369
370 b->boolop = boolop;
371 b->args = args;
372 b->location = location;
373
374 return (Expr *) b;
375 }
376
377 /*
378 * makeAlias -
379 * creates an Alias node
380 *
381 * NOTE: the given name is copied, but the colnames list (if any) isn't.
382 */
383 Alias *
makeAlias(const char * aliasname,List * colnames)384 makeAlias(const char *aliasname, List *colnames)
385 {
386 Alias *a = makeNode(Alias);
387
388 a->aliasname = pstrdup(aliasname);
389 a->colnames = colnames;
390
391 return a;
392 }
393
394 /*
395 * makeRelabelType -
396 * creates a RelabelType node
397 */
398 RelabelType *
makeRelabelType(Expr * arg,Oid rtype,int32 rtypmod,Oid rcollid,CoercionForm rformat)399 makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid,
400 CoercionForm rformat)
401 {
402 RelabelType *r = makeNode(RelabelType);
403
404 r->arg = arg;
405 r->resulttype = rtype;
406 r->resulttypmod = rtypmod;
407 r->resultcollid = rcollid;
408 r->relabelformat = rformat;
409 r->location = -1;
410
411 return r;
412 }
413
414 /*
415 * makeRangeVar -
416 * creates a RangeVar node (rather oversimplified case)
417 */
418 RangeVar *
makeRangeVar(char * schemaname,char * relname,int location)419 makeRangeVar(char *schemaname, char *relname, int location)
420 {
421 RangeVar *r = makeNode(RangeVar);
422
423 r->catalogname = NULL;
424 r->schemaname = schemaname;
425 r->relname = relname;
426 r->inh = true;
427 r->relpersistence = RELPERSISTENCE_PERMANENT;
428 r->alias = NULL;
429 r->location = location;
430
431 return r;
432 }
433
434 /*
435 * makeTypeName -
436 * build a TypeName node for an unqualified name.
437 *
438 * typmod is defaulted, but can be changed later by caller.
439 */
440 TypeName *
makeTypeName(char * typnam)441 makeTypeName(char *typnam)
442 {
443 return makeTypeNameFromNameList(list_make1(makeString(typnam)));
444 }
445
446 /*
447 * makeTypeNameFromNameList -
448 * build a TypeName node for a String list representing a qualified name.
449 *
450 * typmod is defaulted, but can be changed later by caller.
451 */
452 TypeName *
makeTypeNameFromNameList(List * names)453 makeTypeNameFromNameList(List *names)
454 {
455 TypeName *n = makeNode(TypeName);
456
457 n->names = names;
458 n->typmods = NIL;
459 n->typemod = -1;
460 n->location = -1;
461 return n;
462 }
463
464 /*
465 * makeTypeNameFromOid -
466 * build a TypeName node to represent a type already known by OID/typmod.
467 */
468 TypeName *
makeTypeNameFromOid(Oid typeOid,int32 typmod)469 makeTypeNameFromOid(Oid typeOid, int32 typmod)
470 {
471 TypeName *n = makeNode(TypeName);
472
473 n->typeOid = typeOid;
474 n->typemod = typmod;
475 n->location = -1;
476 return n;
477 }
478
479 /*
480 * makeColumnDef -
481 * build a ColumnDef node to represent a simple column definition.
482 *
483 * Type and collation are specified by OID.
484 * Other properties are all basic to start with.
485 */
486 ColumnDef *
makeColumnDef(const char * colname,Oid typeOid,int32 typmod,Oid collOid)487 makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
488 {
489 ColumnDef *n = makeNode(ColumnDef);
490
491 n->colname = pstrdup(colname);
492 n->typeName = makeTypeNameFromOid(typeOid, typmod);
493 n->inhcount = 0;
494 n->is_local = true;
495 n->is_not_null = false;
496 n->is_from_type = false;
497 n->storage = 0;
498 n->raw_default = NULL;
499 n->cooked_default = NULL;
500 n->collClause = NULL;
501 n->collOid = collOid;
502 n->constraints = NIL;
503 n->fdwoptions = NIL;
504 n->location = -1;
505
506 return n;
507 }
508
509 /*
510 * makeFuncExpr -
511 * build an expression tree representing a function call.
512 *
513 * The argument expressions must have been transformed already.
514 */
515 FuncExpr *
makeFuncExpr(Oid funcid,Oid rettype,List * args,Oid funccollid,Oid inputcollid,CoercionForm fformat)516 makeFuncExpr(Oid funcid, Oid rettype, List *args,
517 Oid funccollid, Oid inputcollid, CoercionForm fformat)
518 {
519 FuncExpr *funcexpr;
520
521 funcexpr = makeNode(FuncExpr);
522 funcexpr->funcid = funcid;
523 funcexpr->funcresulttype = rettype;
524 funcexpr->funcretset = false; /* only allowed case here */
525 funcexpr->funcvariadic = false; /* only allowed case here */
526 funcexpr->funcformat = fformat;
527 funcexpr->funccollid = funccollid;
528 funcexpr->inputcollid = inputcollid;
529 funcexpr->args = args;
530 funcexpr->location = -1;
531
532 return funcexpr;
533 }
534
535 /*
536 * makeDefElem -
537 * build a DefElem node
538 *
539 * This is sufficient for the "typical" case with an unqualified option name
540 * and no special action.
541 */
542 DefElem *
makeDefElem(char * name,Node * arg,int location)543 makeDefElem(char *name, Node *arg, int location)
544 {
545 DefElem *res = makeNode(DefElem);
546
547 res->defnamespace = NULL;
548 res->defname = name;
549 res->arg = arg;
550 res->defaction = DEFELEM_UNSPEC;
551 res->location = location;
552
553 return res;
554 }
555
556 /*
557 * makeDefElemExtended -
558 * build a DefElem node with all fields available to be specified
559 */
560 DefElem *
makeDefElemExtended(char * nameSpace,char * name,Node * arg,DefElemAction defaction,int location)561 makeDefElemExtended(char *nameSpace, char *name, Node *arg,
562 DefElemAction defaction, int location)
563 {
564 DefElem *res = makeNode(DefElem);
565
566 res->defnamespace = nameSpace;
567 res->defname = name;
568 res->arg = arg;
569 res->defaction = defaction;
570 res->location = location;
571
572 return res;
573 }
574
575 /*
576 * makeFuncCall -
577 *
578 * Initialize a FuncCall struct with the information every caller must
579 * supply. Any non-default parameters have to be inserted by the caller.
580 */
581 FuncCall *
makeFuncCall(List * name,List * args,int location)582 makeFuncCall(List *name, List *args, int location)
583 {
584 FuncCall *n = makeNode(FuncCall);
585
586 n->funcname = name;
587 n->args = args;
588 n->agg_order = NIL;
589 n->agg_filter = NULL;
590 n->agg_within_group = false;
591 n->agg_star = false;
592 n->agg_distinct = false;
593 n->func_variadic = false;
594 n->over = NULL;
595 n->location = location;
596 return n;
597 }
598
599 /*
600 * makeGroupingSet
601 *
602 */
603 GroupingSet *
makeGroupingSet(GroupingSetKind kind,List * content,int location)604 makeGroupingSet(GroupingSetKind kind, List *content, int location)
605 {
606 GroupingSet *n = makeNode(GroupingSet);
607
608 n->kind = kind;
609 n->content = content;
610 n->location = location;
611 return n;
612 }
613