LCOV - code coverage report
Current view: top level - src/backend/nodes - makefuncs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 364 370 98.4 %
Date: 2025-04-01 15:15:16 Functions: 42 42 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14