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

Generated by: LCOV version 1.14