Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * makefuncs.c
4 : : * creator functions for various nodes. The functions here are for the
5 : : * most frequently created nodes.
6 : : *
7 : : * Portions Copyright (c) 1996-2026, 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 "nodes/makefuncs.h"
21 : : #include "nodes/nodeFuncs.h"
22 : : #include "utils/lsyscache.h"
23 : :
24 : :
25 : : /*
26 : : * makeA_Expr -
27 : : * makes an A_Expr node
28 : : */
29 : : A_Expr *
30 : 9061 : makeA_Expr(A_Expr_Kind kind, List *name,
31 : : Node *lexpr, Node *rexpr, int location)
32 : : {
33 : 9061 : A_Expr *a = makeNode(A_Expr);
34 : :
35 : 9061 : a->kind = kind;
36 : 9061 : a->name = name;
37 : 9061 : a->lexpr = lexpr;
38 : 9061 : a->rexpr = rexpr;
39 : 9061 : a->location = location;
40 : 18122 : return a;
41 : 9061 : }
42 : :
43 : : /*
44 : : * makeSimpleA_Expr -
45 : : * As above, given a simple (unqualified) operator name
46 : : */
47 : : A_Expr *
48 : 47278 : makeSimpleA_Expr(A_Expr_Kind kind, char *name,
49 : : Node *lexpr, Node *rexpr, int location)
50 : : {
51 : 47278 : A_Expr *a = makeNode(A_Expr);
52 : :
53 : 47278 : a->kind = kind;
54 : 47278 : a->name = list_make1(makeString(name));
55 : 47278 : a->lexpr = lexpr;
56 : 47278 : a->rexpr = rexpr;
57 : 47278 : a->location = location;
58 : 94556 : return a;
59 : 47278 : }
60 : :
61 : : /*
62 : : * makeVar -
63 : : * creates a Var node
64 : : */
65 : : Var *
66 : 943905 : makeVar(int varno,
67 : : AttrNumber varattno,
68 : : Oid vartype,
69 : : int32 vartypmod,
70 : : Oid varcollid,
71 : : Index varlevelsup)
72 : : {
73 : 943905 : Var *var = makeNode(Var);
74 : :
75 : 943905 : var->varno = varno;
76 : 943905 : var->varattno = varattno;
77 : 943905 : var->vartype = vartype;
78 : 943905 : var->vartypmod = vartypmod;
79 : 943905 : var->varcollid = varcollid;
80 : 943905 : var->varlevelsup = varlevelsup;
81 : :
82 : : /*
83 : : * Only a few callers need to make Var nodes with varreturningtype
84 : : * different from VAR_RETURNING_DEFAULT, non-null varnullingrels, or with
85 : : * varnosyn/varattnosyn different from varno/varattno. We don't provide
86 : : * separate arguments for them, but just initialize them to sensible
87 : : * default values. This reduces code clutter and chance of error for most
88 : : * callers.
89 : : */
90 : 943905 : var->varreturningtype = VAR_RETURNING_DEFAULT;
91 : 943905 : var->varnullingrels = NULL;
92 : 943905 : var->varnosyn = (Index) varno;
93 : 943905 : var->varattnosyn = varattno;
94 : :
95 : : /* Likewise, we just set location to "unknown" here */
96 : 943905 : var->location = -1;
97 : :
98 : 1887810 : return var;
99 : 943905 : }
100 : :
101 : : /*
102 : : * makeVarFromTargetEntry -
103 : : * convenience function to create a same-level Var node from a
104 : : * TargetEntry
105 : : */
106 : : Var *
107 : 10250 : makeVarFromTargetEntry(int varno,
108 : : TargetEntry *tle)
109 : : {
110 : 20500 : return makeVar(varno,
111 : 10250 : tle->resno,
112 : 10250 : exprType((Node *) tle->expr),
113 : 10250 : exprTypmod((Node *) tle->expr),
114 : 10250 : exprCollation((Node *) tle->expr),
115 : : 0);
116 : : }
117 : :
118 : : /*
119 : : * makeWholeRowVar -
120 : : * creates a Var node representing a whole row of the specified RTE
121 : : *
122 : : * A whole-row reference is a Var with varno set to the correct range
123 : : * table entry, and varattno == 0 to signal that it references the whole
124 : : * tuple. (Use of zero here is unclean, since it could easily be confused
125 : : * with error cases, but it's not worth changing now.) The vartype indicates
126 : : * a rowtype; either a named composite type, or a domain over a named
127 : : * composite type (only possible if the RTE is a function returning that),
128 : : * or RECORD. This function encapsulates the logic for determining the
129 : : * correct rowtype OID to use.
130 : : *
131 : : * If allowScalar is true, then for the case where the RTE is a single function
132 : : * returning a non-composite result type, we produce a normal Var referencing
133 : : * the function's result directly, instead of the single-column composite
134 : : * value that the whole-row notation might otherwise suggest.
135 : : */
136 : : Var *
137 : 666 : makeWholeRowVar(RangeTblEntry *rte,
138 : : int varno,
139 : : Index varlevelsup,
140 : : bool allowScalar)
141 : : {
142 : 666 : Var *result;
143 : 666 : Oid toid;
144 : 666 : Node *fexpr;
145 : :
146 [ + + + + ]: 666 : switch (rte->rtekind)
147 : : {
148 : : case RTE_RELATION:
149 : : /* relation: the rowtype is a named composite type */
150 : 441 : toid = get_rel_type_id(rte->relid);
151 [ + - ]: 441 : if (!OidIsValid(toid))
152 [ # # # # ]: 0 : ereport(ERROR,
153 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
154 : : errmsg("relation \"%s\" does not have a composite type",
155 : : get_rel_name(rte->relid))));
156 : 882 : result = makeVar(varno,
157 : : InvalidAttrNumber,
158 : 441 : toid,
159 : : -1,
160 : : InvalidOid,
161 : 441 : varlevelsup);
162 : 441 : break;
163 : :
164 : : case RTE_SUBQUERY:
165 : :
166 : : /*
167 : : * For a standard subquery, the Var should be of RECORD type.
168 : : * However, if we're looking at a subquery that was expanded from
169 : : * a view or SRF (only possible during planning), we must use the
170 : : * appropriate rowtype, so that the resulting Var has the same
171 : : * type that we would have produced from the original RTE.
172 : : */
173 [ + + ]: 95 : if (OidIsValid(rte->relid))
174 : : {
175 : : /* Subquery was expanded from a view */
176 : 20 : toid = get_rel_type_id(rte->relid);
177 [ + - ]: 20 : if (!OidIsValid(toid))
178 [ # # # # ]: 0 : ereport(ERROR,
179 : : (errcode(ERRCODE_WRONG_OBJECT_TYPE),
180 : : errmsg("relation \"%s\" does not have a composite type",
181 : : get_rel_name(rte->relid))));
182 : 20 : }
183 [ + + ]: 75 : else if (rte->functions)
184 : : {
185 : : /*
186 : : * Subquery was expanded from a set-returning function. That
187 : : * would not have happened if there's more than one function
188 : : * or ordinality was requested. We also needn't worry about
189 : : * the allowScalar case, since the planner doesn't use that.
190 : : * Otherwise this must match the RTE_FUNCTION code below.
191 : : */
192 [ + - ]: 2 : Assert(!allowScalar);
193 : 2 : fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
194 : 2 : toid = exprType(fexpr);
195 [ + - ]: 2 : if (!type_is_rowtype(toid))
196 : 0 : toid = RECORDOID;
197 : 2 : }
198 : : else
199 : : {
200 : : /* Normal subquery-in-FROM */
201 : 73 : toid = RECORDOID;
202 : : }
203 : 190 : result = makeVar(varno,
204 : : InvalidAttrNumber,
205 : 95 : toid,
206 : : -1,
207 : : InvalidOid,
208 : 95 : varlevelsup);
209 : 95 : break;
210 : :
211 : : case RTE_FUNCTION:
212 : :
213 : : /*
214 : : * If there's more than one function, or ordinality is requested,
215 : : * force a RECORD result, since there's certainly more than one
216 : : * column involved and it can't be a known named type.
217 : : */
218 [ + + - + ]: 28 : if (rte->funcordinality || list_length(rte->functions) != 1)
219 : : {
220 : : /* always produces an anonymous RECORD result */
221 : 2 : result = makeVar(varno,
222 : : InvalidAttrNumber,
223 : : RECORDOID,
224 : : -1,
225 : : InvalidOid,
226 : 1 : varlevelsup);
227 : 1 : break;
228 : : }
229 : :
230 : 27 : fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
231 : 27 : toid = exprType(fexpr);
232 [ + + ]: 27 : if (type_is_rowtype(toid))
233 : : {
234 : : /* func returns composite; same as relation case */
235 : 24 : result = makeVar(varno,
236 : : InvalidAttrNumber,
237 : 12 : toid,
238 : : -1,
239 : : InvalidOid,
240 : 12 : varlevelsup);
241 : 12 : }
242 [ + + ]: 15 : else if (allowScalar)
243 : : {
244 : : /* func returns scalar; just return its output as-is */
245 : 8 : result = makeVar(varno,
246 : : 1,
247 : 4 : toid,
248 : : -1,
249 : 4 : exprCollation(fexpr),
250 : 4 : varlevelsup);
251 : 4 : }
252 : : else
253 : : {
254 : : /* func returns scalar, but we want a composite result */
255 : 22 : result = makeVar(varno,
256 : : InvalidAttrNumber,
257 : : RECORDOID,
258 : : -1,
259 : : InvalidOid,
260 : 11 : varlevelsup);
261 : : }
262 : 27 : break;
263 : :
264 : : default:
265 : :
266 : : /*
267 : : * RTE is a join, tablefunc, VALUES, CTE, etc. We represent these
268 : : * cases as a whole-row Var of RECORD type. (Note that in most
269 : : * cases the Var will be expanded to a RowExpr during planning,
270 : : * but that is not our concern here.)
271 : : */
272 : 204 : result = makeVar(varno,
273 : : InvalidAttrNumber,
274 : : RECORDOID,
275 : : -1,
276 : : InvalidOid,
277 : 102 : varlevelsup);
278 : 102 : break;
279 : : }
280 : :
281 : 1332 : return result;
282 : 666 : }
283 : :
284 : : /*
285 : : * makeTargetEntry -
286 : : * creates a TargetEntry node
287 : : */
288 : : TargetEntry *
289 : 820237 : makeTargetEntry(Expr *expr,
290 : : AttrNumber resno,
291 : : char *resname,
292 : : bool resjunk)
293 : : {
294 : 820237 : TargetEntry *tle = makeNode(TargetEntry);
295 : :
296 : 820237 : tle->expr = expr;
297 : 820237 : tle->resno = resno;
298 : 820237 : tle->resname = resname;
299 : :
300 : : /*
301 : : * We always set these fields to 0. If the caller wants to change them he
302 : : * must do so explicitly. Few callers do that, so omitting these
303 : : * arguments reduces the chance of error.
304 : : */
305 : 820237 : tle->ressortgroupref = 0;
306 : 820237 : tle->resorigtbl = InvalidOid;
307 : 820237 : tle->resorigcol = 0;
308 : :
309 : 820237 : tle->resjunk = resjunk;
310 : :
311 : 1640474 : return tle;
312 : 820237 : }
313 : :
314 : : /*
315 : : * flatCopyTargetEntry -
316 : : * duplicate a TargetEntry, but don't copy substructure
317 : : *
318 : : * This is commonly used when we just want to modify the resno or substitute
319 : : * a new expression.
320 : : */
321 : : TargetEntry *
322 : 74590 : flatCopyTargetEntry(TargetEntry *src_tle)
323 : : {
324 : 74590 : TargetEntry *tle = makeNode(TargetEntry);
325 : :
326 [ + - ]: 74590 : Assert(IsA(src_tle, TargetEntry));
327 : 74590 : memcpy(tle, src_tle, sizeof(TargetEntry));
328 : 149180 : return tle;
329 : 74590 : }
330 : :
331 : : /*
332 : : * makeFromExpr -
333 : : * creates a FromExpr node
334 : : */
335 : : FromExpr *
336 : 61023 : makeFromExpr(List *fromlist, Node *quals)
337 : : {
338 : 61023 : FromExpr *f = makeNode(FromExpr);
339 : :
340 : 61023 : f->fromlist = fromlist;
341 : 61023 : f->quals = quals;
342 : 122046 : return f;
343 : 61023 : }
344 : :
345 : : /*
346 : : * makeConst -
347 : : * creates a Const node
348 : : */
349 : : Const *
350 : 196678 : makeConst(Oid consttype,
351 : : int32 consttypmod,
352 : : Oid constcollid,
353 : : int constlen,
354 : : Datum constvalue,
355 : : bool constisnull,
356 : : bool constbyval)
357 : : {
358 : 196678 : Const *cnst = makeNode(Const);
359 : :
360 : : /*
361 : : * If it's a varlena value, force it to be in non-expanded (non-toasted)
362 : : * format; this avoids any possible dependency on external values and
363 : : * improves consistency of representation, which is important for equal().
364 : : */
365 [ + + + + ]: 196678 : if (!constisnull && constlen == -1)
366 : 19382 : constvalue = PointerGetDatum(PG_DETOAST_DATUM(constvalue));
367 : :
368 : 196678 : cnst->consttype = consttype;
369 : 196678 : cnst->consttypmod = consttypmod;
370 : 196678 : cnst->constcollid = constcollid;
371 : 196678 : cnst->constlen = constlen;
372 : 196678 : cnst->constvalue = constvalue;
373 : 196678 : cnst->constisnull = constisnull;
374 : 196678 : cnst->constbyval = constbyval;
375 : 196678 : cnst->location = -1; /* "unknown" */
376 : :
377 : 393356 : return cnst;
378 : 196678 : }
379 : :
380 : : /*
381 : : * makeNullConst -
382 : : * creates a Const node representing a NULL of the specified type/typmod
383 : : *
384 : : * This is a convenience routine that just saves a lookup of the type's
385 : : * storage properties.
386 : : */
387 : : Const *
388 : 1889 : makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
389 : : {
390 : 1889 : int16 typLen;
391 : 1889 : bool typByVal;
392 : :
393 : 1889 : get_typlenbyval(consttype, &typLen, &typByVal);
394 : 5667 : return makeConst(consttype,
395 : 1889 : consttypmod,
396 : 1889 : constcollid,
397 : 1889 : (int) typLen,
398 : : (Datum) 0,
399 : : true,
400 : 1889 : typByVal);
401 : 1889 : }
402 : :
403 : : /*
404 : : * makeBoolConst -
405 : : * creates a Const node representing a boolean value (can be NULL too)
406 : : */
407 : : Node *
408 : 1155 : makeBoolConst(bool value, bool isnull)
409 : : {
410 : : /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
411 : 1155 : return (Node *) makeConst(BOOLOID, -1, InvalidOid, 1,
412 : 1155 : BoolGetDatum(value), isnull, true);
413 : : }
414 : :
415 : : /*
416 : : * makeBoolExpr -
417 : : * creates a BoolExpr node
418 : : */
419 : : Expr *
420 : 26469 : makeBoolExpr(BoolExprType boolop, List *args, int location)
421 : : {
422 : 26469 : BoolExpr *b = makeNode(BoolExpr);
423 : :
424 : 26469 : b->boolop = boolop;
425 : 26469 : b->args = args;
426 : 26469 : b->location = location;
427 : :
428 : 52938 : return (Expr *) b;
429 : 26469 : }
430 : :
431 : : /*
432 : : * makeAlias -
433 : : * creates an Alias node
434 : : *
435 : : * NOTE: the given name is copied, but the colnames list (if any) isn't.
436 : : */
437 : : Alias *
438 : 102277 : makeAlias(const char *aliasname, List *colnames)
439 : : {
440 : 102277 : Alias *a = makeNode(Alias);
441 : :
442 : 102277 : a->aliasname = pstrdup(aliasname);
443 : 102277 : a->colnames = colnames;
444 : :
445 : 204554 : return a;
446 : 102277 : }
447 : :
448 : : /*
449 : : * makeRelabelType -
450 : : * creates a RelabelType node
451 : : */
452 : : RelabelType *
453 : 10860 : makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid,
454 : : CoercionForm rformat)
455 : : {
456 : 10860 : RelabelType *r = makeNode(RelabelType);
457 : :
458 : 10860 : r->arg = arg;
459 : 10860 : r->resulttype = rtype;
460 : 10860 : r->resulttypmod = rtypmod;
461 : 10860 : r->resultcollid = rcollid;
462 : 10860 : r->relabelformat = rformat;
463 : 10860 : r->location = -1;
464 : :
465 : 21720 : return r;
466 : 10860 : }
467 : :
468 : : /*
469 : : * makeRangeVar -
470 : : * creates a RangeVar node (rather oversimplified case)
471 : : */
472 : : RangeVar *
473 : 67556 : makeRangeVar(char *schemaname, char *relname, int location)
474 : : {
475 : 67556 : RangeVar *r = makeNode(RangeVar);
476 : :
477 : 67556 : r->catalogname = NULL;
478 : 67556 : r->schemaname = schemaname;
479 : 67556 : r->relname = relname;
480 : 67556 : r->inh = true;
481 : 67556 : r->relpersistence = RELPERSISTENCE_PERMANENT;
482 : 67556 : r->alias = NULL;
483 : 67556 : r->location = location;
484 : :
485 : 135112 : return r;
486 : 67556 : }
487 : :
488 : : /*
489 : : * makeNotNullConstraint -
490 : : * creates a Constraint node for NOT NULL constraints
491 : : */
492 : : Constraint *
493 : 1006 : makeNotNullConstraint(String *colname)
494 : : {
495 : 1006 : Constraint *notnull;
496 : :
497 : 1006 : notnull = makeNode(Constraint);
498 : 1006 : notnull->contype = CONSTR_NOTNULL;
499 : 1006 : notnull->conname = NULL;
500 : 1006 : notnull->is_no_inherit = false;
501 : 1006 : notnull->deferrable = false;
502 : 1006 : notnull->initdeferred = false;
503 : 1006 : notnull->location = -1;
504 : 1006 : notnull->keys = list_make1(colname);
505 : 1006 : notnull->is_enforced = true;
506 : 1006 : notnull->skip_validation = false;
507 : 1006 : notnull->initially_valid = true;
508 : :
509 : 2012 : return notnull;
510 : 1006 : }
511 : :
512 : : /*
513 : : * makeTypeName -
514 : : * build a TypeName node for an unqualified name.
515 : : *
516 : : * typmod is defaulted, but can be changed later by caller.
517 : : */
518 : : TypeName *
519 : 16898 : makeTypeName(char *typnam)
520 : : {
521 : 16898 : return makeTypeNameFromNameList(list_make1(makeString(typnam)));
522 : : }
523 : :
524 : : /*
525 : : * makeTypeNameFromNameList -
526 : : * build a TypeName node for a String list representing a qualified name.
527 : : *
528 : : * typmod is defaulted, but can be changed later by caller.
529 : : */
530 : : TypeName *
531 : 43487 : makeTypeNameFromNameList(List *names)
532 : : {
533 : 43487 : TypeName *n = makeNode(TypeName);
534 : :
535 : 43487 : n->names = names;
536 : 43487 : n->typmods = NIL;
537 : 43487 : n->typemod = -1;
538 : 43487 : n->location = -1;
539 : 86974 : return n;
540 : 43487 : }
541 : :
542 : : /*
543 : : * makeTypeNameFromOid -
544 : : * build a TypeName node to represent a type already known by OID/typmod.
545 : : */
546 : : TypeName *
547 : 7966 : makeTypeNameFromOid(Oid typeOid, int32 typmod)
548 : : {
549 : 7966 : TypeName *n = makeNode(TypeName);
550 : :
551 : 7966 : n->typeOid = typeOid;
552 : 7966 : n->typemod = typmod;
553 : 7966 : n->location = -1;
554 : 15932 : return n;
555 : 7966 : }
556 : :
557 : : /*
558 : : * makeColumnDef -
559 : : * build a ColumnDef node to represent a simple column definition.
560 : : *
561 : : * Type and collation are specified by OID.
562 : : * Other properties are all basic to start with.
563 : : */
564 : : ColumnDef *
565 : 7780 : makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
566 : : {
567 : 7780 : ColumnDef *n = makeNode(ColumnDef);
568 : :
569 : 7780 : n->colname = pstrdup(colname);
570 : 7780 : n->typeName = makeTypeNameFromOid(typeOid, typmod);
571 : 7780 : n->inhcount = 0;
572 : 7780 : n->is_local = true;
573 : 7780 : n->is_not_null = false;
574 : 7780 : n->is_from_type = false;
575 : 7780 : n->storage = 0;
576 : 7780 : n->raw_default = NULL;
577 : 7780 : n->cooked_default = NULL;
578 : 7780 : n->collClause = NULL;
579 : 7780 : n->collOid = collOid;
580 : 7780 : n->constraints = NIL;
581 : 7780 : n->fdwoptions = NIL;
582 : 7780 : n->location = -1;
583 : :
584 : 15560 : return n;
585 : 7780 : }
586 : :
587 : : /*
588 : : * makeFuncExpr -
589 : : * build an expression tree representing a function call.
590 : : *
591 : : * The argument expressions must have been transformed already.
592 : : */
593 : : FuncExpr *
594 : 20206 : makeFuncExpr(Oid funcid, Oid rettype, List *args,
595 : : Oid funccollid, Oid inputcollid, CoercionForm fformat)
596 : : {
597 : 20206 : FuncExpr *funcexpr;
598 : :
599 : 20206 : funcexpr = makeNode(FuncExpr);
600 : 20206 : funcexpr->funcid = funcid;
601 : 20206 : funcexpr->funcresulttype = rettype;
602 : 20206 : funcexpr->funcretset = false; /* only allowed case here */
603 : 20206 : funcexpr->funcvariadic = false; /* only allowed case here */
604 : 20206 : funcexpr->funcformat = fformat;
605 : 20206 : funcexpr->funccollid = funccollid;
606 : 20206 : funcexpr->inputcollid = inputcollid;
607 : 20206 : funcexpr->args = args;
608 : 20206 : funcexpr->location = -1;
609 : :
610 : 40412 : return funcexpr;
611 : 20206 : }
612 : :
613 : : /*
614 : : * makeStringConst -
615 : : * build a A_Const node of type T_String for given string
616 : : */
617 : : Node *
618 : 62904 : makeStringConst(char *str, int location)
619 : : {
620 : 62904 : A_Const *n = makeNode(A_Const);
621 : :
622 : 62904 : n->val.sval.type = T_String;
623 : 62904 : n->val.sval.sval = str;
624 : 62904 : n->location = location;
625 : :
626 : 125808 : return (Node *) n;
627 : 62904 : }
628 : :
629 : : /*
630 : : * makeDefElem -
631 : : * build a DefElem node
632 : : *
633 : : * This is sufficient for the "typical" case with an unqualified option name
634 : : * and no special action.
635 : : */
636 : : DefElem *
637 : 111723 : makeDefElem(char *name, Node *arg, int location)
638 : : {
639 : 111723 : DefElem *res = makeNode(DefElem);
640 : :
641 : 111723 : res->defnamespace = NULL;
642 : 111723 : res->defname = name;
643 : 111723 : res->arg = arg;
644 : 111723 : res->defaction = DEFELEM_UNSPEC;
645 : 111723 : res->location = location;
646 : :
647 : 223446 : return res;
648 : 111723 : }
649 : :
650 : : /*
651 : : * makeDefElemExtended -
652 : : * build a DefElem node with all fields available to be specified
653 : : */
654 : : DefElem *
655 : 23 : makeDefElemExtended(char *nameSpace, char *name, Node *arg,
656 : : DefElemAction defaction, int location)
657 : : {
658 : 23 : DefElem *res = makeNode(DefElem);
659 : :
660 : 23 : res->defnamespace = nameSpace;
661 : 23 : res->defname = name;
662 : 23 : res->arg = arg;
663 : 23 : res->defaction = defaction;
664 : 23 : res->location = location;
665 : :
666 : 46 : return res;
667 : 23 : }
668 : :
669 : : /*
670 : : * makeFuncCall -
671 : : *
672 : : * Initialize a FuncCall struct with the information every caller must
673 : : * supply. Any non-default parameters have to be inserted by the caller.
674 : : */
675 : : FuncCall *
676 : 33755 : makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
677 : : {
678 : 33755 : FuncCall *n = makeNode(FuncCall);
679 : :
680 : 33755 : n->funcname = name;
681 : 33755 : n->args = args;
682 : 33755 : n->agg_order = NIL;
683 : 33755 : n->agg_filter = NULL;
684 : 33755 : n->over = NULL;
685 : 33755 : n->agg_within_group = false;
686 : 33755 : n->agg_star = false;
687 : 33755 : n->agg_distinct = false;
688 : 33755 : n->func_variadic = false;
689 : 33755 : n->funcformat = funcformat;
690 : 33755 : n->location = location;
691 : 67510 : return n;
692 : 33755 : }
693 : :
694 : : /*
695 : : * make_opclause
696 : : * Creates an operator clause given its operator info, left operand
697 : : * and right operand (pass NULL to create single-operand clause),
698 : : * and collation info.
699 : : */
700 : : Expr *
701 : 17948 : make_opclause(Oid opno, Oid opresulttype, bool opretset,
702 : : Expr *leftop, Expr *rightop,
703 : : Oid opcollid, Oid inputcollid)
704 : : {
705 : 17948 : OpExpr *expr = makeNode(OpExpr);
706 : :
707 : 17948 : expr->opno = opno;
708 : 17948 : expr->opfuncid = InvalidOid;
709 : 17948 : expr->opresulttype = opresulttype;
710 : 17948 : expr->opretset = opretset;
711 : 17948 : expr->opcollid = opcollid;
712 : 17948 : expr->inputcollid = inputcollid;
713 [ + - ]: 17948 : if (rightop)
714 : 17948 : expr->args = list_make2(leftop, rightop);
715 : : else
716 : 0 : expr->args = list_make1(leftop);
717 : 17948 : expr->location = -1;
718 : 35896 : return (Expr *) expr;
719 : 17948 : }
720 : :
721 : : /*
722 : : * make_andclause
723 : : *
724 : : * Creates an 'and' clause given a list of its subclauses.
725 : : */
726 : : Expr *
727 : 32512 : make_andclause(List *andclauses)
728 : : {
729 : 32512 : BoolExpr *expr = makeNode(BoolExpr);
730 : :
731 : 32512 : expr->boolop = AND_EXPR;
732 : 32512 : expr->args = andclauses;
733 : 32512 : expr->location = -1;
734 : 65024 : return (Expr *) expr;
735 : 32512 : }
736 : :
737 : : /*
738 : : * make_orclause
739 : : *
740 : : * Creates an 'or' clause given a list of its subclauses.
741 : : */
742 : : Expr *
743 : 3802 : make_orclause(List *orclauses)
744 : : {
745 : 3802 : BoolExpr *expr = makeNode(BoolExpr);
746 : :
747 : 3802 : expr->boolop = OR_EXPR;
748 : 3802 : expr->args = orclauses;
749 : 3802 : expr->location = -1;
750 : 7604 : return (Expr *) expr;
751 : 3802 : }
752 : :
753 : : /*
754 : : * make_notclause
755 : : *
756 : : * Create a 'not' clause given the expression to be negated.
757 : : */
758 : : Expr *
759 : 1507 : make_notclause(Expr *notclause)
760 : : {
761 : 1507 : BoolExpr *expr = makeNode(BoolExpr);
762 : :
763 : 1507 : expr->boolop = NOT_EXPR;
764 : 1507 : expr->args = list_make1(notclause);
765 : 1507 : expr->location = -1;
766 : 3014 : return (Expr *) expr;
767 : 1507 : }
768 : :
769 : : /*
770 : : * make_and_qual
771 : : *
772 : : * Variant of make_andclause for ANDing two qual conditions together.
773 : : * Qual conditions have the property that a NULL nodetree is interpreted
774 : : * as 'true'.
775 : : *
776 : : * NB: this makes no attempt to preserve AND/OR flatness; so it should not
777 : : * be used on a qual that has already been run through prepqual.c.
778 : : */
779 : : Node *
780 : 667 : make_and_qual(Node *qual1, Node *qual2)
781 : : {
782 [ + + ]: 667 : if (qual1 == NULL)
783 : 256 : return qual2;
784 [ + - ]: 411 : if (qual2 == NULL)
785 : 0 : return qual1;
786 : 411 : return (Node *) make_andclause(list_make2(qual1, qual2));
787 : 667 : }
788 : :
789 : : /*
790 : : * The planner and executor usually represent qualification expressions
791 : : * as lists of boolean expressions with implicit AND semantics.
792 : : *
793 : : * These functions convert between an AND-semantics expression list and the
794 : : * ordinary representation of a boolean expression.
795 : : *
796 : : * Note that an empty list is considered equivalent to TRUE.
797 : : */
798 : : Expr *
799 : 7626 : make_ands_explicit(List *andclauses)
800 : : {
801 [ + - ]: 7626 : if (andclauses == NIL)
802 : 0 : return (Expr *) makeBoolConst(true, false);
803 [ + + ]: 7626 : else if (list_length(andclauses) == 1)
804 : 5419 : return (Expr *) linitial(andclauses);
805 : : else
806 : 2207 : return make_andclause(andclauses);
807 : 7626 : }
808 : :
809 : : List *
810 : 44634 : make_ands_implicit(Expr *clause)
811 : : {
812 : : /*
813 : : * NB: because the parser sets the qual field to NULL in a query that has
814 : : * no WHERE clause, we must consider a NULL input clause as TRUE, even
815 : : * though one might more reasonably think it FALSE.
816 : : */
817 [ + + ]: 44634 : if (clause == NULL)
818 : 6243 : return NIL; /* NULL -> NIL list == TRUE */
819 [ + + ]: 38391 : else if (is_andclause(clause))
820 : 12083 : return ((BoolExpr *) clause)->args;
821 [ + + ]: 26308 : else if (IsA(clause, Const) &&
822 [ + + + + ]: 510 : !((Const *) clause)->constisnull &&
823 : 492 : DatumGetBool(((Const *) clause)->constvalue))
824 : 282 : return NIL; /* constant TRUE input -> NIL list */
825 : : else
826 : 26026 : return list_make1(clause);
827 : 44634 : }
828 : :
829 : : /*
830 : : * makeIndexInfo
831 : : * create an IndexInfo node
832 : : */
833 : : IndexInfo *
834 : 270158 : makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions,
835 : : List *predicates, bool unique, bool nulls_not_distinct,
836 : : bool isready, bool concurrent, bool summarizing,
837 : : bool withoutoverlaps)
838 : : {
839 : 270158 : IndexInfo *n = makeNode(IndexInfo);
840 : :
841 : 270158 : n->ii_NumIndexAttrs = numattrs;
842 : 270158 : n->ii_NumIndexKeyAttrs = numkeyattrs;
843 [ + - ]: 270158 : Assert(n->ii_NumIndexKeyAttrs != 0);
844 [ + - ]: 270158 : Assert(n->ii_NumIndexKeyAttrs <= n->ii_NumIndexAttrs);
845 : 270158 : n->ii_Unique = unique;
846 : 270158 : n->ii_NullsNotDistinct = nulls_not_distinct;
847 : 270158 : n->ii_ReadyForInserts = isready;
848 : 270158 : n->ii_CheckedUnchanged = false;
849 : 270158 : n->ii_IndexUnchanged = false;
850 : 270158 : n->ii_Concurrent = concurrent;
851 : 270158 : n->ii_Summarizing = summarizing;
852 : 270158 : n->ii_WithoutOverlaps = withoutoverlaps;
853 : :
854 : : /* summarizing indexes cannot contain non-key attributes */
855 [ + + + - ]: 270158 : Assert(!summarizing || (numkeyattrs == numattrs));
856 : :
857 : : /* expressions */
858 : 270158 : n->ii_Expressions = expressions;
859 : 270158 : n->ii_ExpressionsState = NIL;
860 : :
861 : : /* predicates */
862 : 270158 : n->ii_Predicate = predicates;
863 : 270158 : n->ii_PredicateState = NULL;
864 : :
865 : : /* exclusion constraints */
866 : 270158 : n->ii_ExclusionOps = NULL;
867 : 270158 : n->ii_ExclusionProcs = NULL;
868 : 270158 : n->ii_ExclusionStrats = NULL;
869 : :
870 : : /* speculative inserts */
871 : 270158 : n->ii_UniqueOps = NULL;
872 : 270158 : n->ii_UniqueProcs = NULL;
873 : 270158 : n->ii_UniqueStrats = NULL;
874 : :
875 : : /* initialize index-build state to default */
876 : 270158 : n->ii_BrokenHotChain = false;
877 : 270158 : n->ii_ParallelWorkers = 0;
878 : :
879 : : /* set up for possible use by index AM */
880 : 270158 : n->ii_Am = amoid;
881 : 270158 : n->ii_AmCache = NULL;
882 : 270158 : n->ii_Context = CurrentMemoryContext;
883 : :
884 : 540316 : return n;
885 : 270158 : }
886 : :
887 : : /*
888 : : * makeGroupingSet
889 : : *
890 : : */
891 : : GroupingSet *
892 : 1047 : makeGroupingSet(GroupingSetKind kind, List *content, int location)
893 : : {
894 : 1047 : GroupingSet *n = makeNode(GroupingSet);
895 : :
896 : 1047 : n->kind = kind;
897 : 1047 : n->content = content;
898 : 1047 : n->location = location;
899 : 2094 : return n;
900 : 1047 : }
901 : :
902 : : /*
903 : : * makeVacuumRelation -
904 : : * create a VacuumRelation node
905 : : */
906 : : VacuumRelation *
907 : 1788 : makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
908 : : {
909 : 1788 : VacuumRelation *v = makeNode(VacuumRelation);
910 : :
911 : 1788 : v->relation = relation;
912 : 1788 : v->oid = oid;
913 : 1788 : v->va_cols = va_cols;
914 : 3576 : return v;
915 : 1788 : }
916 : :
917 : : /*
918 : : * makeJsonFormat -
919 : : * creates a JsonFormat node
920 : : */
921 : : JsonFormat *
922 : 1658 : makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
923 : : {
924 : 1658 : JsonFormat *jf = makeNode(JsonFormat);
925 : :
926 : 1658 : jf->format_type = type;
927 : 1658 : jf->encoding = encoding;
928 : 1658 : jf->location = location;
929 : :
930 : 3316 : return jf;
931 : 1658 : }
932 : :
933 : : /*
934 : : * makeJsonValueExpr -
935 : : * creates a JsonValueExpr node
936 : : */
937 : : JsonValueExpr *
938 : 902 : makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr,
939 : : JsonFormat *format)
940 : : {
941 : 902 : JsonValueExpr *jve = makeNode(JsonValueExpr);
942 : :
943 : 902 : jve->raw_expr = raw_expr;
944 : 902 : jve->formatted_expr = formatted_expr;
945 : 902 : jve->format = format;
946 : :
947 : 1804 : return jve;
948 : 902 : }
949 : :
950 : : /*
951 : : * makeJsonBehavior -
952 : : * creates a JsonBehavior node
953 : : */
954 : : JsonBehavior *
955 : 899 : makeJsonBehavior(JsonBehaviorType btype, Node *expr, int location)
956 : : {
957 : 899 : JsonBehavior *behavior = makeNode(JsonBehavior);
958 : :
959 : 899 : behavior->btype = btype;
960 : 899 : behavior->expr = expr;
961 : 899 : behavior->location = location;
962 : :
963 : 1798 : return behavior;
964 : 899 : }
965 : :
966 : : /*
967 : : * makeJsonKeyValue -
968 : : * creates a JsonKeyValue node
969 : : */
970 : : Node *
971 : 130 : makeJsonKeyValue(Node *key, Node *value)
972 : : {
973 : 130 : JsonKeyValue *n = makeNode(JsonKeyValue);
974 : :
975 : 130 : n->key = (Expr *) key;
976 : 130 : n->value = castNode(JsonValueExpr, value);
977 : :
978 : 260 : return (Node *) n;
979 : 130 : }
980 : :
981 : : /*
982 : : * makeJsonIsPredicate -
983 : : * creates a JsonIsPredicate node
984 : : */
985 : : Node *
986 : 105 : makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type,
987 : : bool unique_keys, int location)
988 : : {
989 : 105 : JsonIsPredicate *n = makeNode(JsonIsPredicate);
990 : :
991 : 105 : n->expr = expr;
992 : 105 : n->format = format;
993 : 105 : n->item_type = item_type;
994 : 105 : n->unique_keys = unique_keys;
995 : 105 : n->location = location;
996 : :
997 : 210 : return (Node *) n;
998 : 105 : }
999 : :
1000 : : /*
1001 : : * makeJsonTablePathSpec -
1002 : : * Make JsonTablePathSpec node from given path string and name (if any)
1003 : : */
1004 : : JsonTablePathSpec *
1005 : 272 : makeJsonTablePathSpec(char *string, char *name, int string_location,
1006 : : int name_location)
1007 : : {
1008 : 272 : JsonTablePathSpec *pathspec = makeNode(JsonTablePathSpec);
1009 : :
1010 [ + - ]: 272 : Assert(string != NULL);
1011 : 272 : pathspec->string = makeStringConst(string, string_location);
1012 [ + + ]: 272 : if (name != NULL)
1013 : 32 : pathspec->name = pstrdup(name);
1014 : :
1015 : 272 : pathspec->name_location = name_location;
1016 : 272 : pathspec->location = string_location;
1017 : :
1018 : 544 : return pathspec;
1019 : 272 : }
1020 : :
1021 : : /*
1022 : : * makeJsonTablePath -
1023 : : * Make JsonTablePath node for given path string and name
1024 : : */
1025 : : JsonTablePath *
1026 : 115 : makeJsonTablePath(Const *pathvalue, char *pathname)
1027 : : {
1028 : 115 : JsonTablePath *path = makeNode(JsonTablePath);
1029 : :
1030 [ + - ]: 115 : Assert(IsA(pathvalue, Const));
1031 : 115 : path->value = pathvalue;
1032 : 115 : path->name = pathname;
1033 : :
1034 : 230 : return path;
1035 : 115 : }
|
