PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
makefuncs.c
Go to the documentation of this file.
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 */
29A_Expr *
31 Node *lexpr, Node *rexpr, int location)
32{
34
35 a->kind = kind;
36 a->name = name;
37 a->lexpr = lexpr;
38 a->rexpr = rexpr;
39 a->location = location;
40 return a;
41}
42
43/*
44 * makeSimpleA_Expr -
45 * As above, given a simple (unqualified) operator name
46 */
47A_Expr *
49 Node *lexpr, Node *rexpr, int location)
50{
52
53 a->kind = kind;
54 a->name = list_make1(makeString((char *) name));
55 a->lexpr = lexpr;
56 a->rexpr = rexpr;
57 a->location = location;
58 return a;
59}
60
61/*
62 * makeVar -
63 * creates a Var node
64 */
65Var *
66makeVar(int varno,
67 AttrNumber varattno,
68 Oid vartype,
69 int32 vartypmod,
70 Oid varcollid,
71 Index varlevelsup)
72{
73 Var *var = makeNode(Var);
74
75 var->varno = varno;
76 var->varattno = varattno;
77 var->vartype = vartype;
78 var->vartypmod = vartypmod;
79 var->varcollid = varcollid;
80 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 */
89 var->varnullingrels = NULL;
90 var->varnosyn = (Index) varno;
91 var->varattnosyn = varattno;
92
93 /* Likewise, we just set location to "unknown" here */
94 var->location = -1;
95
96 return var;
97}
98
99/*
100 * makeVarFromTargetEntry -
101 * convenience function to create a same-level Var node from a
102 * TargetEntry
103 */
104Var *
106 TargetEntry *tle)
107{
108 return makeVar(varno,
109 tle->resno,
110 exprType((Node *) tle->expr),
111 exprTypmod((Node *) tle->expr),
112 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 */
134Var *
136 int varno,
137 Index varlevelsup,
138 bool allowScalar)
139{
140 Var *result;
141 Oid toid;
142 Node *fexpr;
143
144 switch (rte->rtekind)
145 {
146 case RTE_RELATION:
147 /* relation: the rowtype is a named composite type */
148 toid = get_rel_type_id(rte->relid);
149 if (!OidIsValid(toid))
151 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
152 errmsg("relation \"%s\" does not have a composite type",
153 get_rel_name(rte->relid))));
154 result = makeVar(varno,
156 toid,
157 -1,
159 varlevelsup);
160 break;
161
162 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 */
169 if (rte->funcordinality || list_length(rte->functions) != 1)
170 {
171 /* always produces an anonymous RECORD result */
172 result = makeVar(varno,
174 RECORDOID,
175 -1,
177 varlevelsup);
178 break;
179 }
180
181 fexpr = ((RangeTblFunction *) linitial(rte->functions))->funcexpr;
182 toid = exprType(fexpr);
183 if (type_is_rowtype(toid))
184 {
185 /* func returns composite; same as relation case */
186 result = makeVar(varno,
188 toid,
189 -1,
191 varlevelsup);
192 }
193 else if (allowScalar)
194 {
195 /* func returns scalar; just return its output as-is */
196 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 */
206 result = makeVar(varno,
208 RECORDOID,
209 -1,
211 varlevelsup);
212 }
213 break;
214
215 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 */
223 result = makeVar(varno,
225 RECORDOID,
226 -1,
228 varlevelsup);
229 break;
230 }
231
232 return result;
233}
234
235/*
236 * makeTargetEntry -
237 * creates a TargetEntry node
238 */
241 AttrNumber resno,
242 char *resname,
243 bool resjunk)
244{
246
247 tle->expr = expr;
248 tle->resno = resno;
249 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 tle->ressortgroupref = 0;
257 tle->resorigtbl = InvalidOid;
258 tle->resorigcol = 0;
259
260 tle->resjunk = resjunk;
261
262 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 */
274{
276
277 Assert(IsA(src_tle, TargetEntry));
278 memcpy(tle, src_tle, sizeof(TargetEntry));
279 return tle;
280}
281
282/*
283 * makeFromExpr -
284 * creates a FromExpr node
285 */
286FromExpr *
287makeFromExpr(List *fromlist, Node *quals)
288{
290
291 f->fromlist = fromlist;
292 f->quals = quals;
293 return f;
294}
295
296/*
297 * makeConst -
298 * creates a Const node
299 */
300Const *
301makeConst(Oid consttype,
302 int32 consttypmod,
303 Oid constcollid,
304 int constlen,
305 Datum constvalue,
306 bool constisnull,
307 bool constbyval)
308{
309 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 */
316 if (!constisnull && constlen == -1)
317 constvalue = PointerGetDatum(PG_DETOAST_DATUM(constvalue));
318
319 cnst->consttype = consttype;
320 cnst->consttypmod = consttypmod;
321 cnst->constcollid = constcollid;
322 cnst->constlen = constlen;
323 cnst->constvalue = constvalue;
324 cnst->constisnull = constisnull;
325 cnst->constbyval = constbyval;
326 cnst->location = -1; /* "unknown" */
327
328 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 */
338Const *
339makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
340{
341 int16 typLen;
342 bool typByVal;
343
344 get_typlenbyval(consttype, &typLen, &typByVal);
345 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 */
358Node *
359makeBoolConst(bool value, bool isnull)
360{
361 /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
362 return (Node *) makeConst(BOOLOID, -1, InvalidOid, 1,
363 BoolGetDatum(value), isnull, true);
364}
365
366/*
367 * makeBoolExpr -
368 * creates a BoolExpr node
369 */
370Expr *
372{
374
375 b->boolop = boolop;
376 b->args = args;
377 b->location = location;
378
379 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 */
388Alias *
389makeAlias(const char *aliasname, List *colnames)
390{
391 Alias *a = makeNode(Alias);
392
393 a->aliasname = pstrdup(aliasname);
394 a->colnames = colnames;
395
396 return a;
397}
398
399/*
400 * makeRelabelType -
401 * creates a RelabelType node
402 */
404makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid,
405 CoercionForm rformat)
406{
408
409 r->arg = arg;
410 r->resulttype = rtype;
411 r->resulttypmod = rtypmod;
412 r->resultcollid = rcollid;
413 r->relabelformat = rformat;
414 r->location = -1;
415
416 return r;
417}
418
419/*
420 * makeRangeVar -
421 * creates a RangeVar node (rather oversimplified case)
422 */
423RangeVar *
424makeRangeVar(char *schemaname, char *relname, int location)
425{
427
428 r->catalogname = NULL;
429 r->schemaname = schemaname;
430 r->relname = relname;
431 r->inh = true;
432 r->relpersistence = RELPERSISTENCE_PERMANENT;
433 r->alias = NULL;
434 r->location = location;
435
436 return r;
437}
438
439/*
440 * makeNotNullConstraint -
441 * creates a Constraint node for NOT NULL constraints
442 */
445{
446 Constraint *notnull;
447
448 notnull = makeNode(Constraint);
449 notnull->contype = CONSTR_NOTNULL;
450 notnull->conname = NULL;
451 notnull->is_no_inherit = false;
452 notnull->deferrable = false;
453 notnull->initdeferred = false;
454 notnull->location = -1;
455 notnull->keys = list_make1(colname);
456 notnull->skip_validation = false;
457 notnull->initially_valid = true;
458
459 return notnull;
460}
461
462/*
463 * makeTypeName -
464 * build a TypeName node for an unqualified name.
465 *
466 * typmod is defaulted, but can be changed later by caller.
467 */
468TypeName *
469makeTypeName(char *typnam)
470{
472}
473
474/*
475 * makeTypeNameFromNameList -
476 * build a TypeName node for a String list representing a qualified name.
477 *
478 * typmod is defaulted, but can be changed later by caller.
479 */
480TypeName *
482{
484
485 n->names = names;
486 n->typmods = NIL;
487 n->typemod = -1;
488 n->location = -1;
489 return n;
490}
491
492/*
493 * makeTypeNameFromOid -
494 * build a TypeName node to represent a type already known by OID/typmod.
495 */
496TypeName *
498{
500
501 n->typeOid = typeOid;
502 n->typemod = typmod;
503 n->location = -1;
504 return n;
505}
506
507/*
508 * makeColumnDef -
509 * build a ColumnDef node to represent a simple column definition.
510 *
511 * Type and collation are specified by OID.
512 * Other properties are all basic to start with.
513 */
514ColumnDef *
515makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
516{
518
519 n->colname = pstrdup(colname);
520 n->typeName = makeTypeNameFromOid(typeOid, typmod);
521 n->inhcount = 0;
522 n->is_local = true;
523 n->is_not_null = false;
524 n->is_from_type = false;
525 n->storage = 0;
526 n->raw_default = NULL;
527 n->cooked_default = NULL;
528 n->collClause = NULL;
529 n->collOid = collOid;
530 n->constraints = NIL;
531 n->fdwoptions = NIL;
532 n->location = -1;
533
534 return n;
535}
536
537/*
538 * makeFuncExpr -
539 * build an expression tree representing a function call.
540 *
541 * The argument expressions must have been transformed already.
542 */
543FuncExpr *
544makeFuncExpr(Oid funcid, Oid rettype, List *args,
545 Oid funccollid, Oid inputcollid, CoercionForm fformat)
546{
547 FuncExpr *funcexpr;
548
549 funcexpr = makeNode(FuncExpr);
550 funcexpr->funcid = funcid;
551 funcexpr->funcresulttype = rettype;
552 funcexpr->funcretset = false; /* only allowed case here */
553 funcexpr->funcvariadic = false; /* only allowed case here */
554 funcexpr->funcformat = fformat;
555 funcexpr->funccollid = funccollid;
556 funcexpr->inputcollid = inputcollid;
557 funcexpr->args = args;
558 funcexpr->location = -1;
559
560 return funcexpr;
561}
562
563/*
564 * makeStringConst -
565 * build a A_Const node of type T_String for given string
566 */
567Node *
568makeStringConst(char *str, int location)
569{
571
572 n->val.sval.type = T_String;
573 n->val.sval.sval = str;
574 n->location = location;
575
576 return (Node *) n;
577}
578
579/*
580 * makeDefElem -
581 * build a DefElem node
582 *
583 * This is sufficient for the "typical" case with an unqualified option name
584 * and no special action.
585 */
586DefElem *
587makeDefElem(char *name, Node *arg, int location)
588{
590
591 res->defnamespace = NULL;
592 res->defname = name;
593 res->arg = arg;
594 res->defaction = DEFELEM_UNSPEC;
595 res->location = location;
596
597 return res;
598}
599
600/*
601 * makeDefElemExtended -
602 * build a DefElem node with all fields available to be specified
603 */
604DefElem *
605makeDefElemExtended(char *nameSpace, char *name, Node *arg,
606 DefElemAction defaction, int location)
607{
609
610 res->defnamespace = nameSpace;
611 res->defname = name;
612 res->arg = arg;
613 res->defaction = defaction;
614 res->location = location;
615
616 return res;
617}
618
619/*
620 * makeFuncCall -
621 *
622 * Initialize a FuncCall struct with the information every caller must
623 * supply. Any non-default parameters have to be inserted by the caller.
624 */
625FuncCall *
626makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
627{
629
630 n->funcname = name;
631 n->args = args;
632 n->agg_order = NIL;
633 n->agg_filter = NULL;
634 n->over = NULL;
635 n->agg_within_group = false;
636 n->agg_star = false;
637 n->agg_distinct = false;
638 n->func_variadic = false;
639 n->funcformat = funcformat;
640 n->location = location;
641 return n;
642}
643
644/*
645 * make_opclause
646 * Creates an operator clause given its operator info, left operand
647 * and right operand (pass NULL to create single-operand clause),
648 * and collation info.
649 */
650Expr *
651make_opclause(Oid opno, Oid opresulttype, bool opretset,
652 Expr *leftop, Expr *rightop,
653 Oid opcollid, Oid inputcollid)
654{
655 OpExpr *expr = makeNode(OpExpr);
656
657 expr->opno = opno;
658 expr->opfuncid = InvalidOid;
659 expr->opresulttype = opresulttype;
660 expr->opretset = opretset;
661 expr->opcollid = opcollid;
662 expr->inputcollid = inputcollid;
663 if (rightop)
664 expr->args = list_make2(leftop, rightop);
665 else
666 expr->args = list_make1(leftop);
667 expr->location = -1;
668 return (Expr *) expr;
669}
670
671/*
672 * make_andclause
673 *
674 * Creates an 'and' clause given a list of its subclauses.
675 */
676Expr *
678{
679 BoolExpr *expr = makeNode(BoolExpr);
680
681 expr->boolop = AND_EXPR;
682 expr->args = andclauses;
683 expr->location = -1;
684 return (Expr *) expr;
685}
686
687/*
688 * make_orclause
689 *
690 * Creates an 'or' clause given a list of its subclauses.
691 */
692Expr *
694{
695 BoolExpr *expr = makeNode(BoolExpr);
696
697 expr->boolop = OR_EXPR;
698 expr->args = orclauses;
699 expr->location = -1;
700 return (Expr *) expr;
701}
702
703/*
704 * make_notclause
705 *
706 * Create a 'not' clause given the expression to be negated.
707 */
708Expr *
710{
711 BoolExpr *expr = makeNode(BoolExpr);
712
713 expr->boolop = NOT_EXPR;
714 expr->args = list_make1(notclause);
715 expr->location = -1;
716 return (Expr *) expr;
717}
718
719/*
720 * make_and_qual
721 *
722 * Variant of make_andclause for ANDing two qual conditions together.
723 * Qual conditions have the property that a NULL nodetree is interpreted
724 * as 'true'.
725 *
726 * NB: this makes no attempt to preserve AND/OR flatness; so it should not
727 * be used on a qual that has already been run through prepqual.c.
728 */
729Node *
730make_and_qual(Node *qual1, Node *qual2)
731{
732 if (qual1 == NULL)
733 return qual2;
734 if (qual2 == NULL)
735 return qual1;
736 return (Node *) make_andclause(list_make2(qual1, qual2));
737}
738
739/*
740 * The planner and executor usually represent qualification expressions
741 * as lists of boolean expressions with implicit AND semantics.
742 *
743 * These functions convert between an AND-semantics expression list and the
744 * ordinary representation of a boolean expression.
745 *
746 * Note that an empty list is considered equivalent to TRUE.
747 */
748Expr *
750{
751 if (andclauses == NIL)
752 return (Expr *) makeBoolConst(true, false);
753 else if (list_length(andclauses) == 1)
754 return (Expr *) linitial(andclauses);
755 else
756 return make_andclause(andclauses);
757}
758
759List *
761{
762 /*
763 * NB: because the parser sets the qual field to NULL in a query that has
764 * no WHERE clause, we must consider a NULL input clause as TRUE, even
765 * though one might more reasonably think it FALSE.
766 */
767 if (clause == NULL)
768 return NIL; /* NULL -> NIL list == TRUE */
769 else if (is_andclause(clause))
770 return ((BoolExpr *) clause)->args;
771 else if (IsA(clause, Const) &&
772 !((Const *) clause)->constisnull &&
773 DatumGetBool(((Const *) clause)->constvalue))
774 return NIL; /* constant TRUE input -> NIL list */
775 else
776 return list_make1(clause);
777}
778
779/*
780 * makeIndexInfo
781 * create an IndexInfo node
782 */
783IndexInfo *
784makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions,
785 List *predicates, bool unique, bool nulls_not_distinct,
786 bool isready, bool concurrent, bool summarizing,
787 bool withoutoverlaps)
788{
790
791 n->ii_NumIndexAttrs = numattrs;
792 n->ii_NumIndexKeyAttrs = numkeyattrs;
795 n->ii_Unique = unique;
796 n->ii_NullsNotDistinct = nulls_not_distinct;
797 n->ii_ReadyForInserts = isready;
798 n->ii_CheckedUnchanged = false;
799 n->ii_IndexUnchanged = false;
800 n->ii_Concurrent = concurrent;
801 n->ii_Summarizing = summarizing;
802 n->ii_WithoutOverlaps = withoutoverlaps;
803
804 /* summarizing indexes cannot contain non-key attributes */
805 Assert(!summarizing || (numkeyattrs == numattrs));
806
807 /* expressions */
808 n->ii_Expressions = expressions;
810
811 /* predicates */
812 n->ii_Predicate = predicates;
813 n->ii_PredicateState = NULL;
814
815 /* exclusion constraints */
816 n->ii_ExclusionOps = NULL;
817 n->ii_ExclusionProcs = NULL;
818 n->ii_ExclusionStrats = NULL;
819
820 /* speculative inserts */
821 n->ii_UniqueOps = NULL;
822 n->ii_UniqueProcs = NULL;
823 n->ii_UniqueStrats = NULL;
824
825 /* initialize index-build state to default */
826 n->ii_BrokenHotChain = false;
827 n->ii_ParallelWorkers = 0;
828
829 /* set up for possible use by index AM */
830 n->ii_Am = amoid;
831 n->ii_AmCache = NULL;
833
834 return n;
835}
836
837/*
838 * makeGroupingSet
839 *
840 */
842makeGroupingSet(GroupingSetKind kind, List *content, int location)
843{
845
846 n->kind = kind;
847 n->content = content;
848 n->location = location;
849 return n;
850}
851
852/*
853 * makeVacuumRelation -
854 * create a VacuumRelation node
855 */
857makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
858{
860
861 v->relation = relation;
862 v->oid = oid;
863 v->va_cols = va_cols;
864 return v;
865}
866
867/*
868 * makeJsonFormat -
869 * creates a JsonFormat node
870 */
873{
875
876 jf->format_type = type;
877 jf->encoding = encoding;
878 jf->location = location;
879
880 return jf;
881}
882
883/*
884 * makeJsonValueExpr -
885 * creates a JsonValueExpr node
886 */
888makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr,
890{
892
893 jve->raw_expr = raw_expr;
894 jve->formatted_expr = formatted_expr;
895 jve->format = format;
896
897 return jve;
898}
899
900/*
901 * makeJsonBehavior -
902 * creates a JsonBehavior node
903 */
905makeJsonBehavior(JsonBehaviorType btype, Node *expr, int location)
906{
908
909 behavior->btype = btype;
910 behavior->expr = expr;
911 behavior->location = location;
912
913 return behavior;
914}
915
916/*
917 * makeJsonKeyValue -
918 * creates a JsonKeyValue node
919 */
920Node *
922{
924
925 n->key = (Expr *) key;
927
928 return (Node *) n;
929}
930
931/*
932 * makeJsonIsPredicate -
933 * creates a JsonIsPredicate node
934 */
935Node *
937 bool unique_keys, int location)
938{
940
941 n->expr = expr;
942 n->format = format;
943 n->item_type = item_type;
944 n->unique_keys = unique_keys;
945 n->location = location;
946
947 return (Node *) n;
948}
949
950/*
951 * makeJsonTablePathSpec -
952 * Make JsonTablePathSpec node from given path string and name (if any)
953 */
955makeJsonTablePathSpec(char *string, char *name, int string_location,
956 int name_location)
957{
959
960 Assert(string != NULL);
961 pathspec->string = makeStringConst(string, string_location);
962 if (name != NULL)
963 pathspec->name = pstrdup(name);
964
965 pathspec->name_location = name_location;
966 pathspec->location = string_location;
967
968 return pathspec;
969}
970
971/*
972 * makeJsonTablePath -
973 * Make JsonTablePath node for given path string and name
974 */
976makeJsonTablePath(Const *pathvalue, char *pathname)
977{
979
980 Assert(IsA(pathvalue, Const));
981 path->value = pathvalue;
982 path->name = pathname;
983
984 return path;
985}
Datum boolop(PG_FUNCTION_ARGS)
Definition: _int_bool.c:417
int16 AttrNumber
Definition: attnum.h:21
#define InvalidAttrNumber
Definition: attnum.h:23
#define Assert(condition)
Definition: c.h:812
int16_t int16
Definition: c.h:480
int32_t int32
Definition: c.h:481
unsigned int Index
Definition: c.h:568
#define OidIsValid(objectId)
Definition: c.h:729
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
#define PG_DETOAST_DATUM(datum)
Definition: fmgr.h:240
const char * str
static struct @161 value
int b
Definition: isn.c:69
int a
Definition: isn.c:68
char * get_rel_name(Oid relid)
Definition: lsyscache.c:1928
bool type_is_rowtype(Oid typid)
Definition: lsyscache.c:2655
void get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
Definition: lsyscache.c:2251
Oid get_rel_type_id(Oid relid)
Definition: lsyscache.c:1979
Alias * makeAlias(const char *aliasname, List *colnames)
Definition: makefuncs.c:389
Expr * make_orclause(List *orclauses)
Definition: makefuncs.c:693
Expr * make_ands_explicit(List *andclauses)
Definition: makefuncs.c:749
Expr * makeBoolExpr(BoolExprType boolop, List *args, int location)
Definition: makefuncs.c:371
VacuumRelation * makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
Definition: makefuncs.c:857
DefElem * makeDefElem(char *name, Node *arg, int location)
Definition: makefuncs.c:587
A_Expr * makeA_Expr(A_Expr_Kind kind, List *name, Node *lexpr, Node *rexpr, int location)
Definition: makefuncs.c:30
TypeName * makeTypeNameFromNameList(List *names)
Definition: makefuncs.c:481
Var * makeVarFromTargetEntry(int varno, TargetEntry *tle)
Definition: makefuncs.c:105
FromExpr * makeFromExpr(List *fromlist, Node *quals)
Definition: makefuncs.c:287
JsonBehavior * makeJsonBehavior(JsonBehaviorType btype, Node *expr, int location)
Definition: makefuncs.c:905
IndexInfo * makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, List *predicates, bool unique, bool nulls_not_distinct, bool isready, bool concurrent, bool summarizing, bool withoutoverlaps)
Definition: makefuncs.c:784
JsonTablePath * makeJsonTablePath(Const *pathvalue, char *pathname)
Definition: makefuncs.c:976
DefElem * makeDefElemExtended(char *nameSpace, char *name, Node *arg, DefElemAction defaction, int location)
Definition: makefuncs.c:605
A_Expr * makeSimpleA_Expr(A_Expr_Kind kind, char *name, Node *lexpr, Node *rexpr, int location)
Definition: makefuncs.c:48
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition: makefuncs.c:66
Node * makeJsonKeyValue(Node *key, Node *value)
Definition: makefuncs.c:921
ColumnDef * makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
Definition: makefuncs.c:515
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition: makefuncs.c:339
Var * makeWholeRowVar(RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)
Definition: makefuncs.c:135
Node * makeBoolConst(bool value, bool isnull)
Definition: makefuncs.c:359
RelabelType * makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, Oid rcollid, CoercionForm rformat)
Definition: makefuncs.c:404
Node * makeStringConst(char *str, int location)
Definition: makefuncs.c:568
RangeVar * makeRangeVar(char *schemaname, char *relname, int location)
Definition: makefuncs.c:424
TypeName * makeTypeName(char *typnam)
Definition: makefuncs.c:469
Expr * make_andclause(List *andclauses)
Definition: makefuncs.c:677
FuncCall * makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
Definition: makefuncs.c:626
JsonTablePathSpec * makeJsonTablePathSpec(char *string, char *name, int string_location, int name_location)
Definition: makefuncs.c:955
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:240
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:544
Expr * make_opclause(Oid opno, Oid opresulttype, bool opretset, Expr *leftop, Expr *rightop, Oid opcollid, Oid inputcollid)
Definition: makefuncs.c:651
Constraint * makeNotNullConstraint(String *colname)
Definition: makefuncs.c:444
Expr * make_notclause(Expr *notclause)
Definition: makefuncs.c:709
JsonValueExpr * makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr, JsonFormat *format)
Definition: makefuncs.c:888
Node * make_and_qual(Node *qual1, Node *qual2)
Definition: makefuncs.c:730
JsonFormat * makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
Definition: makefuncs.c:872
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:301
GroupingSet * makeGroupingSet(GroupingSetKind kind, List *content, int location)
Definition: makefuncs.c:842
List * make_ands_implicit(Expr *clause)
Definition: makefuncs.c:760
TypeName * makeTypeNameFromOid(Oid typeOid, int32 typmod)
Definition: makefuncs.c:497
TargetEntry * flatCopyTargetEntry(TargetEntry *src_tle)
Definition: makefuncs.c:273
Node * makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type, bool unique_keys, int location)
Definition: makefuncs.c:936
char * pstrdup(const char *in)
Definition: mcxt.c:1696
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:298
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:816
static bool is_andclause(const void *clause)
Definition: nodeFuncs.h:107
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
#define makeNode(_type_)
Definition: nodes.h:155
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
GroupingSetKind
Definition: parsenodes.h:1498
A_Expr_Kind
Definition: parsenodes.h:314
@ RTE_FUNCTION
Definition: parsenodes.h:1020
@ RTE_RELATION
Definition: parsenodes.h:1017
DefElemAction
Definition: parsenodes.h:806
@ DEFELEM_UNSPEC
Definition: parsenodes.h:807
@ CONSTR_NOTNULL
Definition: parsenodes.h:2726
void * arg
static char format
NameData relname
Definition: pg_class.h:38
int32 encoding
Definition: pg_database.h:41
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define list_make1(x1)
Definition: pg_list.h:212
#define linitial(l)
Definition: pg_list.h:178
#define list_make2(x1, x2)
Definition: pg_list.h:214
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
JsonFormatType
Definition: primnodes.h:1637
BoolExprType
Definition: primnodes.h:930
@ AND_EXPR
Definition: primnodes.h:931
@ OR_EXPR
Definition: primnodes.h:931
@ NOT_EXPR
Definition: primnodes.h:931
JsonEncoding
Definition: primnodes.h:1625
JsonBehaviorType
Definition: primnodes.h:1764
CoercionForm
Definition: primnodes.h:733
JsonValueType
Definition: primnodes.h:1721
union ValUnion val
Definition: parsenodes.h:364
ParseLoc location
Definition: parsenodes.h:366
BoolExprType boolop
Definition: primnodes.h:939
List * args
Definition: primnodes.h:940
ParseLoc location
Definition: primnodes.h:941
bool is_not_null
Definition: parsenodes.h:733
CollateClause * collClause
Definition: parsenodes.h:743
List * constraints
Definition: parsenodes.h:745
Node * cooked_default
Definition: parsenodes.h:738
char * colname
Definition: parsenodes.h:728
TypeName * typeName
Definition: parsenodes.h:729
bool is_from_type
Definition: parsenodes.h:734
List * fdwoptions
Definition: parsenodes.h:746
Node * raw_default
Definition: parsenodes.h:737
char storage
Definition: parsenodes.h:735
Oid collOid
Definition: parsenodes.h:744
bool is_local
Definition: parsenodes.h:732
int16 inhcount
Definition: parsenodes.h:731
ParseLoc location
Definition: parsenodes.h:747
Oid consttype
Definition: primnodes.h:312
bool initdeferred
Definition: parsenodes.h:2759
ParseLoc location
Definition: parsenodes.h:2798
List * keys
Definition: parsenodes.h:2769
ConstrType contype
Definition: parsenodes.h:2756
bool is_no_inherit
Definition: parsenodes.h:2762
bool initially_valid
Definition: parsenodes.h:2761
bool skip_validation
Definition: parsenodes.h:2760
bool deferrable
Definition: parsenodes.h:2758
char * conname
Definition: parsenodes.h:2757
Node * quals
Definition: primnodes.h:2309
List * fromlist
Definition: primnodes.h:2308
bool agg_within_group
Definition: parsenodes.h:433
CoercionForm funcformat
Definition: parsenodes.h:437
Node * agg_filter
Definition: parsenodes.h:431
List * agg_order
Definition: parsenodes.h:430
List * funcname
Definition: parsenodes.h:428
List * args
Definition: parsenodes.h:429
bool agg_star
Definition: parsenodes.h:434
bool agg_distinct
Definition: parsenodes.h:435
ParseLoc location
Definition: parsenodes.h:438
bool func_variadic
Definition: parsenodes.h:436
struct WindowDef * over
Definition: parsenodes.h:432
ParseLoc location
Definition: primnodes.h:770
Oid funcid
Definition: primnodes.h:750
List * args
Definition: primnodes.h:768
List * content
Definition: parsenodes.h:1510
ParseLoc location
Definition: parsenodes.h:1511
bool ii_Unique
Definition: execnodes.h:199
uint16 * ii_ExclusionStrats
Definition: execnodes.h:195
bool ii_BrokenHotChain
Definition: execnodes.h:205
int ii_NumIndexAttrs
Definition: execnodes.h:186
void * ii_AmCache
Definition: execnodes.h:210
bool ii_CheckedUnchanged
Definition: execnodes.h:202
Oid * ii_UniqueOps
Definition: execnodes.h:196
ExprState * ii_PredicateState
Definition: execnodes.h:192
Oid * ii_ExclusionOps
Definition: execnodes.h:193
bool ii_NullsNotDistinct
Definition: execnodes.h:200
int ii_ParallelWorkers
Definition: execnodes.h:208
bool ii_Concurrent
Definition: execnodes.h:204
uint16 * ii_UniqueStrats
Definition: execnodes.h:198
int ii_NumIndexKeyAttrs
Definition: execnodes.h:187
List * ii_ExpressionsState
Definition: execnodes.h:190
List * ii_Expressions
Definition: execnodes.h:189
bool ii_WithoutOverlaps
Definition: execnodes.h:207
bool ii_IndexUnchanged
Definition: execnodes.h:203
Oid * ii_ExclusionProcs
Definition: execnodes.h:194
Oid ii_Am
Definition: execnodes.h:209
bool ii_Summarizing
Definition: execnodes.h:206
Oid * ii_UniqueProcs
Definition: execnodes.h:197
MemoryContext ii_Context
Definition: execnodes.h:211
bool ii_ReadyForInserts
Definition: execnodes.h:201
List * ii_Predicate
Definition: execnodes.h:191
Node * expr
Definition: primnodes.h:1791
ParseLoc location
Definition: primnodes.h:1793
JsonBehaviorType btype
Definition: primnodes.h:1790
ParseLoc location
Definition: primnodes.h:1653
JsonEncoding encoding
Definition: primnodes.h:1652
JsonFormatType format_type
Definition: primnodes.h:1651
JsonFormat * format
Definition: primnodes.h:1736
JsonValueType item_type
Definition: primnodes.h:1737
ParseLoc location
Definition: primnodes.h:1739
JsonValueExpr * value
Definition: parsenodes.h:1876
ParseLoc name_location
Definition: parsenodes.h:1813
Const * value
Definition: primnodes.h:1871
Expr * formatted_expr
Definition: primnodes.h:1684
JsonFormat * format
Definition: primnodes.h:1685
Expr * raw_expr
Definition: primnodes.h:1683
Definition: pg_list.h:54
Definition: nodes.h:129
Oid opno
Definition: primnodes.h:818
List * args
Definition: primnodes.h:836
ParseLoc location
Definition: primnodes.h:839
bool funcordinality
Definition: parsenodes.h:1179
List * functions
Definition: parsenodes.h:1177
RTEKind rtekind
Definition: parsenodes.h:1047
char * relname
Definition: primnodes.h:82
bool inh
Definition: primnodes.h:85
Alias * alias
Definition: primnodes.h:91
char relpersistence
Definition: primnodes.h:88
char * catalogname
Definition: primnodes.h:76
ParseLoc location
Definition: primnodes.h:94
char * schemaname
Definition: primnodes.h:79
Oid resulttype
Definition: primnodes.h:1185
ParseLoc location
Definition: primnodes.h:1192
Expr * arg
Definition: primnodes.h:1184
Definition: value.h:64
char * sval
Definition: value.h:68
Expr * expr
Definition: primnodes.h:2190
AttrNumber resno
Definition: primnodes.h:2192
Index ressortgroupref
Definition: primnodes.h:2196
Oid typeOid
Definition: parsenodes.h:271
List * names
Definition: parsenodes.h:270
int32 typemod
Definition: parsenodes.h:275
ParseLoc location
Definition: parsenodes.h:277
List * typmods
Definition: parsenodes.h:274
RangeVar * relation
Definition: parsenodes.h:3883
Definition: primnodes.h:248
ParseLoc location
Definition: primnodes.h:293
AttrNumber varattno
Definition: primnodes.h:260
int varno
Definition: primnodes.h:255
Index varlevelsup
Definition: primnodes.h:280
String sval
Definition: parsenodes.h:355
String * makeString(char *str)
Definition: value.c:63
const char * type
const char * name