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