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