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