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 48679 : makeA_Expr(A_Expr_Kind kind, List *name,
31 : Node *lexpr, Node *rexpr, int location)
32 : {
33 48679 : A_Expr *a = makeNode(A_Expr);
34 :
35 48679 : a->kind = kind;
36 48679 : a->name = name;
37 48679 : a->lexpr = lexpr;
38 48679 : a->rexpr = rexpr;
39 48679 : a->location = location;
40 48679 : return a;
41 : }
42 :
43 : /*
44 : * makeSimpleA_Expr -
45 : * As above, given a simple (unqualified) operator name
46 : */
47 : A_Expr *
48 368680 : makeSimpleA_Expr(A_Expr_Kind kind, char *name,
49 : Node *lexpr, Node *rexpr, int location)
50 : {
51 368680 : A_Expr *a = makeNode(A_Expr);
52 :
53 368680 : a->kind = kind;
54 368680 : a->name = list_make1(makeString(name));
55 368680 : a->lexpr = lexpr;
56 368680 : a->rexpr = rexpr;
57 368680 : a->location = location;
58 368680 : return a;
59 : }
60 :
61 : /*
62 : * makeVar -
63 : * creates a Var node
64 : */
65 : Var *
66 7380379 : makeVar(int varno,
67 : AttrNumber varattno,
68 : Oid vartype,
69 : int32 vartypmod,
70 : Oid varcollid,
71 : Index varlevelsup)
72 : {
73 7380379 : Var *var = makeNode(Var);
74 :
75 7380379 : var->varno = varno;
76 7380379 : var->varattno = varattno;
77 7380379 : var->vartype = vartype;
78 7380379 : var->vartypmod = vartypmod;
79 7380379 : var->varcollid = varcollid;
80 7380379 : 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 7380379 : var->varreturningtype = VAR_RETURNING_DEFAULT;
91 7380379 : var->varnullingrels = NULL;
92 7380379 : var->varnosyn = (Index) varno;
93 7380379 : var->varattnosyn = varattno;
94 :
95 : /* Likewise, we just set location to "unknown" here */
96 7380379 : var->location = -1;
97 :
98 7380379 : return var;
99 : }
100 :
101 : /*
102 : * makeVarFromTargetEntry -
103 : * convenience function to create a same-level Var node from a
104 : * TargetEntry
105 : */
106 : Var *
107 106084 : makeVarFromTargetEntry(int varno,
108 : TargetEntry *tle)
109 : {
110 530420 : return makeVar(varno,
111 106084 : tle->resno,
112 106084 : exprType((Node *) tle->expr),
113 106084 : exprTypmod((Node *) tle->expr),
114 106084 : 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 5992 : makeWholeRowVar(RangeTblEntry *rte,
138 : int varno,
139 : Index varlevelsup,
140 : bool allowScalar)
141 : {
142 : Var *result;
143 : Oid toid;
144 : Node *fexpr;
145 :
146 5992 : switch (rte->rtekind)
147 : {
148 4883 : case RTE_RELATION:
149 : /* relation: the rowtype is a named composite type */
150 4883 : toid = get_rel_type_id(rte->relid);
151 4883 : 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 4883 : result = makeVar(varno,
157 : InvalidAttrNumber,
158 : toid,
159 : -1,
160 : InvalidOid,
161 : varlevelsup);
162 4883 : break;
163 :
164 478 : 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 478 : if (OidIsValid(rte->relid))
174 : {
175 : /* Subquery was expanded from a view */
176 100 : toid = get_rel_type_id(rte->relid);
177 100 : 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 : }
183 378 : 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 : Assert(!allowScalar);
193 10 : fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
194 10 : toid = exprType(fexpr);
195 10 : if (!type_is_rowtype(toid))
196 0 : toid = RECORDOID;
197 : }
198 : else
199 : {
200 : /* Normal subquery-in-FROM */
201 368 : toid = RECORDOID;
202 : }
203 478 : result = makeVar(varno,
204 : InvalidAttrNumber,
205 : toid,
206 : -1,
207 : InvalidOid,
208 : varlevelsup);
209 478 : break;
210 :
211 133 : 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 133 : if (rte->funcordinality || list_length(rte->functions) != 1)
219 : {
220 : /* always produces an anonymous RECORD result */
221 4 : result = makeVar(varno,
222 : InvalidAttrNumber,
223 : RECORDOID,
224 : -1,
225 : InvalidOid,
226 : varlevelsup);
227 4 : break;
228 : }
229 :
230 129 : fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
231 129 : toid = exprType(fexpr);
232 129 : if (type_is_rowtype(toid))
233 : {
234 : /* func returns composite; same as relation case */
235 50 : result = makeVar(varno,
236 : InvalidAttrNumber,
237 : toid,
238 : -1,
239 : InvalidOid,
240 : varlevelsup);
241 : }
242 79 : else if (allowScalar)
243 : {
244 : /* func returns scalar; just return its output as-is */
245 17 : result = makeVar(varno,
246 : 1,
247 : toid,
248 : -1,
249 : exprCollation(fexpr),
250 : varlevelsup);
251 : }
252 : else
253 : {
254 : /* func returns scalar, but we want a composite result */
255 62 : result = makeVar(varno,
256 : InvalidAttrNumber,
257 : RECORDOID,
258 : -1,
259 : InvalidOid,
260 : varlevelsup);
261 : }
262 129 : break;
263 :
264 498 : 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 498 : result = makeVar(varno,
273 : InvalidAttrNumber,
274 : RECORDOID,
275 : -1,
276 : InvalidOid,
277 : varlevelsup);
278 498 : break;
279 : }
280 :
281 5992 : return result;
282 : }
283 :
284 : /*
285 : * makeTargetEntry -
286 : * creates a TargetEntry node
287 : */
288 : TargetEntry *
289 6429627 : makeTargetEntry(Expr *expr,
290 : AttrNumber resno,
291 : char *resname,
292 : bool resjunk)
293 : {
294 6429627 : TargetEntry *tle = makeNode(TargetEntry);
295 :
296 6429627 : tle->expr = expr;
297 6429627 : tle->resno = resno;
298 6429627 : 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 6429627 : tle->ressortgroupref = 0;
306 6429627 : tle->resorigtbl = InvalidOid;
307 6429627 : tle->resorigcol = 0;
308 :
309 6429627 : tle->resjunk = resjunk;
310 :
311 6429627 : return tle;
312 : }
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 532007 : flatCopyTargetEntry(TargetEntry *src_tle)
323 : {
324 532007 : TargetEntry *tle = makeNode(TargetEntry);
325 :
326 : Assert(IsA(src_tle, TargetEntry));
327 532007 : memcpy(tle, src_tle, sizeof(TargetEntry));
328 532007 : return tle;
329 : }
330 :
331 : /*
332 : * makeFromExpr -
333 : * creates a FromExpr node
334 : */
335 : FromExpr *
336 411846 : makeFromExpr(List *fromlist, Node *quals)
337 : {
338 411846 : FromExpr *f = makeNode(FromExpr);
339 :
340 411846 : f->fromlist = fromlist;
341 411846 : f->quals = quals;
342 411846 : return f;
343 : }
344 :
345 : /*
346 : * makeConst -
347 : * creates a Const node
348 : */
349 : Const *
350 1797067 : makeConst(Oid consttype,
351 : int32 consttypmod,
352 : Oid constcollid,
353 : int constlen,
354 : Datum constvalue,
355 : bool constisnull,
356 : bool constbyval)
357 : {
358 1797067 : 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 1797067 : if (!constisnull && constlen == -1)
366 117661 : constvalue = PointerGetDatum(PG_DETOAST_DATUM(constvalue));
367 :
368 1797067 : cnst->consttype = consttype;
369 1797067 : cnst->consttypmod = consttypmod;
370 1797067 : cnst->constcollid = constcollid;
371 1797067 : cnst->constlen = constlen;
372 1797067 : cnst->constvalue = constvalue;
373 1797067 : cnst->constisnull = constisnull;
374 1797067 : cnst->constbyval = constbyval;
375 1797067 : cnst->location = -1; /* "unknown" */
376 :
377 1797067 : return cnst;
378 : }
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 34703 : makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
389 : {
390 : int16 typLen;
391 : bool typByVal;
392 :
393 34703 : get_typlenbyval(consttype, &typLen, &typByVal);
394 34703 : return makeConst(consttype,
395 : consttypmod,
396 : constcollid,
397 : (int) typLen,
398 : (Datum) 0,
399 : true,
400 : typByVal);
401 : }
402 :
403 : /*
404 : * makeBoolConst -
405 : * creates a Const node representing a boolean value (can be NULL too)
406 : */
407 : Node *
408 11075 : makeBoolConst(bool value, bool isnull)
409 : {
410 : /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
411 11075 : return (Node *) makeConst(BOOLOID, -1, InvalidOid, 1,
412 : BoolGetDatum(value), isnull, true);
413 : }
414 :
415 : /*
416 : * makeBoolExpr -
417 : * creates a BoolExpr node
418 : */
419 : Expr *
420 235397 : makeBoolExpr(BoolExprType boolop, List *args, int location)
421 : {
422 235397 : BoolExpr *b = makeNode(BoolExpr);
423 :
424 235397 : b->boolop = boolop;
425 235397 : b->args = args;
426 235397 : b->location = location;
427 :
428 235397 : return (Expr *) b;
429 : }
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 743830 : makeAlias(const char *aliasname, List *colnames)
439 : {
440 743830 : Alias *a = makeNode(Alias);
441 :
442 743830 : a->aliasname = pstrdup(aliasname);
443 743830 : a->colnames = colnames;
444 :
445 743830 : return a;
446 : }
447 :
448 : /*
449 : * makeRelabelType -
450 : * creates a RelabelType node
451 : */
452 : RelabelType *
453 102758 : makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid,
454 : CoercionForm rformat)
455 : {
456 102758 : RelabelType *r = makeNode(RelabelType);
457 :
458 102758 : r->arg = arg;
459 102758 : r->resulttype = rtype;
460 102758 : r->resulttypmod = rtypmod;
461 102758 : r->resultcollid = rcollid;
462 102758 : r->relabelformat = rformat;
463 102758 : r->location = -1;
464 :
465 102758 : return r;
466 : }
467 :
468 : /*
469 : * makeRangeVar -
470 : * creates a RangeVar node (rather oversimplified case)
471 : */
472 : RangeVar *
473 596978 : makeRangeVar(char *schemaname, char *relname, int location)
474 : {
475 596978 : RangeVar *r = makeNode(RangeVar);
476 :
477 596978 : r->catalogname = NULL;
478 596978 : r->schemaname = schemaname;
479 596978 : r->relname = relname;
480 596978 : r->inh = true;
481 596978 : r->relpersistence = RELPERSISTENCE_PERMANENT;
482 596978 : r->alias = NULL;
483 596978 : r->location = location;
484 :
485 596978 : return r;
486 : }
487 :
488 : /*
489 : * makeNotNullConstraint -
490 : * creates a Constraint node for NOT NULL constraints
491 : */
492 : Constraint *
493 9378 : makeNotNullConstraint(String *colname)
494 : {
495 : Constraint *notnull;
496 :
497 9378 : notnull = makeNode(Constraint);
498 9378 : notnull->contype = CONSTR_NOTNULL;
499 9378 : notnull->conname = NULL;
500 9378 : notnull->is_no_inherit = false;
501 9378 : notnull->deferrable = false;
502 9378 : notnull->initdeferred = false;
503 9378 : notnull->location = -1;
504 9378 : notnull->keys = list_make1(colname);
505 9378 : notnull->is_enforced = true;
506 9378 : notnull->skip_validation = false;
507 9378 : notnull->initially_valid = true;
508 :
509 9378 : return notnull;
510 : }
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 165277 : makeTypeName(char *typnam)
520 : {
521 165277 : 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 356750 : makeTypeNameFromNameList(List *names)
532 : {
533 356750 : TypeName *n = makeNode(TypeName);
534 :
535 356750 : n->names = names;
536 356750 : n->typmods = NIL;
537 356750 : n->typemod = -1;
538 356750 : n->location = -1;
539 356750 : return n;
540 : }
541 :
542 : /*
543 : * makeTypeNameFromOid -
544 : * build a TypeName node to represent a type already known by OID/typmod.
545 : */
546 : TypeName *
547 112997 : makeTypeNameFromOid(Oid typeOid, int32 typmod)
548 : {
549 112997 : TypeName *n = makeNode(TypeName);
550 :
551 112997 : n->typeOid = typeOid;
552 112997 : n->typemod = typmod;
553 112997 : n->location = -1;
554 112997 : return n;
555 : }
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 112111 : makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
566 : {
567 112111 : ColumnDef *n = makeNode(ColumnDef);
568 :
569 112111 : n->colname = pstrdup(colname);
570 112111 : n->typeName = makeTypeNameFromOid(typeOid, typmod);
571 112111 : n->inhcount = 0;
572 112111 : n->is_local = true;
573 112111 : n->is_not_null = false;
574 112111 : n->is_from_type = false;
575 112111 : n->storage = 0;
576 112111 : n->raw_default = NULL;
577 112111 : n->cooked_default = NULL;
578 112111 : n->collClause = NULL;
579 112111 : n->collOid = collOid;
580 112111 : n->constraints = NIL;
581 112111 : n->fdwoptions = NIL;
582 112111 : n->location = -1;
583 :
584 112111 : return n;
585 : }
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 111521 : makeFuncExpr(Oid funcid, Oid rettype, List *args,
595 : Oid funccollid, Oid inputcollid, CoercionForm fformat)
596 : {
597 : FuncExpr *funcexpr;
598 :
599 111521 : funcexpr = makeNode(FuncExpr);
600 111521 : funcexpr->funcid = funcid;
601 111521 : funcexpr->funcresulttype = rettype;
602 111521 : funcexpr->funcretset = false; /* only allowed case here */
603 111521 : funcexpr->funcvariadic = false; /* only allowed case here */
604 111521 : funcexpr->funcformat = fformat;
605 111521 : funcexpr->funccollid = funccollid;
606 111521 : funcexpr->inputcollid = inputcollid;
607 111521 : funcexpr->args = args;
608 111521 : funcexpr->location = -1;
609 :
610 111521 : return funcexpr;
611 : }
612 :
613 : /*
614 : * makeStringConst -
615 : * build a A_Const node of type T_String for given string
616 : */
617 : Node *
618 476067 : makeStringConst(char *str, int location)
619 : {
620 476067 : A_Const *n = makeNode(A_Const);
621 :
622 476067 : n->val.sval.type = T_String;
623 476067 : n->val.sval.sval = str;
624 476067 : n->location = location;
625 :
626 476067 : return (Node *) n;
627 : }
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 444455 : makeDefElem(char *name, Node *arg, int location)
638 : {
639 444455 : DefElem *res = makeNode(DefElem);
640 :
641 444455 : res->defnamespace = NULL;
642 444455 : res->defname = name;
643 444455 : res->arg = arg;
644 444455 : res->defaction = DEFELEM_UNSPEC;
645 444455 : res->location = location;
646 :
647 444455 : return res;
648 : }
649 :
650 : /*
651 : * makeDefElemExtended -
652 : * build a DefElem node with all fields available to be specified
653 : */
654 : DefElem *
655 126 : makeDefElemExtended(char *nameSpace, char *name, Node *arg,
656 : DefElemAction defaction, int location)
657 : {
658 126 : DefElem *res = makeNode(DefElem);
659 :
660 126 : res->defnamespace = nameSpace;
661 126 : res->defname = name;
662 126 : res->arg = arg;
663 126 : res->defaction = defaction;
664 126 : res->location = location;
665 :
666 126 : return res;
667 : }
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 241006 : makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
677 : {
678 241006 : FuncCall *n = makeNode(FuncCall);
679 :
680 241006 : n->funcname = name;
681 241006 : n->args = args;
682 241006 : n->agg_order = NIL;
683 241006 : n->agg_filter = NULL;
684 241006 : n->over = NULL;
685 241006 : n->agg_within_group = false;
686 241006 : n->agg_star = false;
687 241006 : n->agg_distinct = false;
688 241006 : n->func_variadic = false;
689 241006 : n->funcformat = funcformat;
690 241006 : n->location = location;
691 241006 : return n;
692 : }
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 132509 : make_opclause(Oid opno, Oid opresulttype, bool opretset,
702 : Expr *leftop, Expr *rightop,
703 : Oid opcollid, Oid inputcollid)
704 : {
705 132509 : OpExpr *expr = makeNode(OpExpr);
706 :
707 132509 : expr->opno = opno;
708 132509 : expr->opfuncid = InvalidOid;
709 132509 : expr->opresulttype = opresulttype;
710 132509 : expr->opretset = opretset;
711 132509 : expr->opcollid = opcollid;
712 132509 : expr->inputcollid = inputcollid;
713 132509 : if (rightop)
714 132509 : expr->args = list_make2(leftop, rightop);
715 : else
716 0 : expr->args = list_make1(leftop);
717 132509 : expr->location = -1;
718 132509 : return (Expr *) expr;
719 : }
720 :
721 : /*
722 : * make_andclause
723 : *
724 : * Creates an 'and' clause given a list of its subclauses.
725 : */
726 : Expr *
727 282490 : make_andclause(List *andclauses)
728 : {
729 282490 : BoolExpr *expr = makeNode(BoolExpr);
730 :
731 282490 : expr->boolop = AND_EXPR;
732 282490 : expr->args = andclauses;
733 282490 : expr->location = -1;
734 282490 : return (Expr *) expr;
735 : }
736 :
737 : /*
738 : * make_orclause
739 : *
740 : * Creates an 'or' clause given a list of its subclauses.
741 : */
742 : Expr *
743 40498 : make_orclause(List *orclauses)
744 : {
745 40498 : BoolExpr *expr = makeNode(BoolExpr);
746 :
747 40498 : expr->boolop = OR_EXPR;
748 40498 : expr->args = orclauses;
749 40498 : expr->location = -1;
750 40498 : return (Expr *) expr;
751 : }
752 :
753 : /*
754 : * make_notclause
755 : *
756 : * Create a 'not' clause given the expression to be negated.
757 : */
758 : Expr *
759 14180 : make_notclause(Expr *notclause)
760 : {
761 14180 : BoolExpr *expr = makeNode(BoolExpr);
762 :
763 14180 : expr->boolop = NOT_EXPR;
764 14180 : expr->args = list_make1(notclause);
765 14180 : expr->location = -1;
766 14180 : return (Expr *) expr;
767 : }
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 4141 : make_and_qual(Node *qual1, Node *qual2)
781 : {
782 4141 : if (qual1 == NULL)
783 1230 : return qual2;
784 2911 : if (qual2 == NULL)
785 0 : return qual1;
786 2911 : return (Node *) make_andclause(list_make2(qual1, qual2));
787 : }
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 37872 : make_ands_explicit(List *andclauses)
800 : {
801 37872 : if (andclauses == NIL)
802 0 : return (Expr *) makeBoolConst(true, false);
803 37872 : else if (list_length(andclauses) == 1)
804 27431 : return (Expr *) linitial(andclauses);
805 : else
806 10441 : return make_andclause(andclauses);
807 : }
808 :
809 : List *
810 345285 : 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 345285 : if (clause == NULL)
818 50234 : return NIL; /* NULL -> NIL list == TRUE */
819 295051 : else if (is_andclause(clause))
820 104705 : return ((BoolExpr *) clause)->args;
821 190346 : else if (IsA(clause, Const) &&
822 5659 : !((Const *) clause)->constisnull &&
823 2759 : DatumGetBool(((Const *) clause)->constvalue))
824 1610 : return NIL; /* constant TRUE input -> NIL list */
825 : else
826 188736 : return list_make1(clause);
827 : }
828 :
829 : /*
830 : * makeIndexInfo
831 : * create an IndexInfo node
832 : */
833 : IndexInfo *
834 2190875 : 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 2190875 : IndexInfo *n = makeNode(IndexInfo);
840 :
841 2190875 : n->ii_NumIndexAttrs = numattrs;
842 2190875 : n->ii_NumIndexKeyAttrs = numkeyattrs;
843 : Assert(n->ii_NumIndexKeyAttrs != 0);
844 : Assert(n->ii_NumIndexKeyAttrs <= n->ii_NumIndexAttrs);
845 2190875 : n->ii_Unique = unique;
846 2190875 : n->ii_NullsNotDistinct = nulls_not_distinct;
847 2190875 : n->ii_ReadyForInserts = isready;
848 2190875 : n->ii_CheckedUnchanged = false;
849 2190875 : n->ii_IndexUnchanged = false;
850 2190875 : n->ii_Concurrent = concurrent;
851 2190875 : n->ii_Summarizing = summarizing;
852 2190875 : n->ii_WithoutOverlaps = withoutoverlaps;
853 :
854 : /* summarizing indexes cannot contain non-key attributes */
855 : Assert(!summarizing || (numkeyattrs == numattrs));
856 :
857 : /* expressions */
858 2190875 : n->ii_Expressions = expressions;
859 2190875 : n->ii_ExpressionsState = NIL;
860 :
861 : /* predicates */
862 2190875 : n->ii_Predicate = predicates;
863 2190875 : n->ii_PredicateState = NULL;
864 :
865 : /* exclusion constraints */
866 2190875 : n->ii_ExclusionOps = NULL;
867 2190875 : n->ii_ExclusionProcs = NULL;
868 2190875 : n->ii_ExclusionStrats = NULL;
869 :
870 : /* speculative inserts */
871 2190875 : n->ii_UniqueOps = NULL;
872 2190875 : n->ii_UniqueProcs = NULL;
873 2190875 : n->ii_UniqueStrats = NULL;
874 :
875 : /* initialize index-build state to default */
876 2190875 : n->ii_BrokenHotChain = false;
877 2190875 : n->ii_ParallelWorkers = 0;
878 :
879 : /* set up for possible use by index AM */
880 2190875 : n->ii_Am = amoid;
881 2190875 : n->ii_AmCache = NULL;
882 2190875 : n->ii_Context = CurrentMemoryContext;
883 :
884 2190875 : return n;
885 : }
886 :
887 : /*
888 : * makeGroupingSet
889 : *
890 : */
891 : GroupingSet *
892 4334 : makeGroupingSet(GroupingSetKind kind, List *content, int location)
893 : {
894 4334 : GroupingSet *n = makeNode(GroupingSet);
895 :
896 4334 : n->kind = kind;
897 4334 : n->content = content;
898 4334 : n->location = location;
899 4334 : return n;
900 : }
901 :
902 : /*
903 : * makeVacuumRelation -
904 : * create a VacuumRelation node
905 : */
906 : VacuumRelation *
907 121220 : makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
908 : {
909 121220 : VacuumRelation *v = makeNode(VacuumRelation);
910 :
911 121220 : v->relation = relation;
912 121220 : v->oid = oid;
913 121220 : v->va_cols = va_cols;
914 121220 : return v;
915 : }
916 :
917 : /*
918 : * makeJsonFormat -
919 : * creates a JsonFormat node
920 : */
921 : JsonFormat *
922 7190 : makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
923 : {
924 7190 : JsonFormat *jf = makeNode(JsonFormat);
925 :
926 7190 : jf->format_type = type;
927 7190 : jf->encoding = encoding;
928 7190 : jf->location = location;
929 :
930 7190 : return jf;
931 : }
932 :
933 : /*
934 : * makeJsonValueExpr -
935 : * creates a JsonValueExpr node
936 : */
937 : JsonValueExpr *
938 3900 : makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr,
939 : JsonFormat *format)
940 : {
941 3900 : JsonValueExpr *jve = makeNode(JsonValueExpr);
942 :
943 3900 : jve->raw_expr = raw_expr;
944 3900 : jve->formatted_expr = formatted_expr;
945 3900 : jve->format = format;
946 :
947 3900 : return jve;
948 : }
949 :
950 : /*
951 : * makeJsonBehavior -
952 : * creates a JsonBehavior node
953 : */
954 : JsonBehavior *
955 3608 : makeJsonBehavior(JsonBehaviorType btype, Node *expr, int location)
956 : {
957 3608 : JsonBehavior *behavior = makeNode(JsonBehavior);
958 :
959 3608 : behavior->btype = btype;
960 3608 : behavior->expr = expr;
961 3608 : behavior->location = location;
962 :
963 3608 : return behavior;
964 : }
965 :
966 : /*
967 : * makeJsonKeyValue -
968 : * creates a JsonKeyValue node
969 : */
970 : Node *
971 630 : makeJsonKeyValue(Node *key, Node *value)
972 : {
973 630 : JsonKeyValue *n = makeNode(JsonKeyValue);
974 :
975 630 : n->key = (Expr *) key;
976 630 : n->value = castNode(JsonValueExpr, value);
977 :
978 630 : return (Node *) n;
979 : }
980 :
981 : /*
982 : * makeJsonIsPredicate -
983 : * creates a JsonIsPredicate node
984 : */
985 : Node *
986 532 : makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type,
987 : bool unique_keys, Oid exprBaseType, int location)
988 : {
989 532 : JsonIsPredicate *n = makeNode(JsonIsPredicate);
990 :
991 532 : n->expr = expr;
992 532 : n->format = format;
993 532 : n->item_type = item_type;
994 532 : n->unique_keys = unique_keys;
995 532 : n->exprBaseType = exprBaseType;
996 532 : n->location = location;
997 :
998 532 : return (Node *) n;
999 : }
1000 :
1001 : /*
1002 : * makeJsonTablePathSpec -
1003 : * Make JsonTablePathSpec node from given path string and name (if any)
1004 : */
1005 : JsonTablePathSpec *
1006 1096 : makeJsonTablePathSpec(char *string, char *name, int string_location,
1007 : int name_location)
1008 : {
1009 1096 : JsonTablePathSpec *pathspec = makeNode(JsonTablePathSpec);
1010 :
1011 : Assert(string != NULL);
1012 1096 : pathspec->string = makeStringConst(string, string_location);
1013 1096 : if (name != NULL)
1014 136 : pathspec->name = pstrdup(name);
1015 :
1016 1096 : pathspec->name_location = name_location;
1017 1096 : pathspec->location = string_location;
1018 :
1019 1096 : return pathspec;
1020 : }
1021 :
1022 : /*
1023 : * makeJsonTablePath -
1024 : * Make JsonTablePath node for given path string and name
1025 : */
1026 : JsonTablePath *
1027 468 : makeJsonTablePath(Const *pathvalue, char *pathname)
1028 : {
1029 468 : JsonTablePath *path = makeNode(JsonTablePath);
1030 :
1031 : Assert(IsA(pathvalue, Const));
1032 468 : path->value = pathvalue;
1033 468 : path->name = pathname;
1034 :
1035 468 : return path;
1036 : }
|
