Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions  Download package

makefuncs.c
/*-------------------------------------------------------------------------
 *
 * makefuncs.c
 *      creator functions for primitive nodes. The functions here are for
 *      the most frequently created nodes.
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/nodes/makefuncs.c,v 1.64 2009/04/04 21:12:31 tgl Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
#include "utils/lsyscache.h"


/*
 * makeA_Expr -
 *          makes an A_Expr node
 */
A_Expr *
makeA_Expr(A_Expr_Kind kind, List *name,
               Node *lexpr, Node *rexpr, int location)
{
      A_Expr         *a = makeNode(A_Expr);

      a->kind = kind;
      a->name = name;
      a->lexpr = lexpr;
      a->rexpr = rexpr;
      a->location = location;
      return a;
}

/*
 * makeSimpleA_Expr -
 *          As above, given a simple (unqualified) operator name
 */
A_Expr *
makeSimpleA_Expr(A_Expr_Kind kind, const char *name,
                         Node *lexpr, Node *rexpr, int location)
{
      A_Expr         *a = makeNode(A_Expr);

      a->kind = kind;
      a->name = list_make1(makeString((char *) name));
      a->lexpr = lexpr;
      a->rexpr = rexpr;
      a->location = location;
      return a;
}

/*
 * makeVar -
 *      creates a Var node
 */
Var *
makeVar(Index varno,
            AttrNumber varattno,
            Oid vartype,
            int32 vartypmod,
            Index varlevelsup)
{
      Var            *var = makeNode(Var);

      var->varno = varno;
      var->varattno = varattno;
      var->vartype = vartype;
      var->vartypmod = vartypmod;
      var->varlevelsup = varlevelsup;

      /*
       * Since few if any routines ever create Var nodes with varnoold/varoattno
       * different from varno/varattno, we don't provide separate arguments for
       * them, but just initialize them to the given varno/varattno. This
       * reduces code clutter and chance of error for most callers.
       */
      var->varnoold = varno;
      var->varoattno = varattno;

      /* Likewise, we just set location to "unknown" here */
      var->location = -1;

      return var;
}

/*
 * makeTargetEntry -
 *      creates a TargetEntry node
 */
TargetEntry *
makeTargetEntry(Expr *expr,
                        AttrNumber resno,
                        char *resname,
                        bool resjunk)
{
      TargetEntry *tle = makeNode(TargetEntry);

      tle->expr = expr;
      tle->resno = resno;
      tle->resname = resname;

      /*
       * We always set these fields to 0. If the caller wants to change them he
       * must do so explicitly.  Few callers do that, so omitting these
       * arguments reduces the chance of error.
       */
      tle->ressortgroupref = 0;
      tle->resorigtbl = InvalidOid;
      tle->resorigcol = 0;

      tle->resjunk = resjunk;

      return tle;
}

/*
 * flatCopyTargetEntry -
 *      duplicate a TargetEntry, but don't copy substructure
 *
 * This is commonly used when we just want to modify the resno or substitute
 * a new expression.
 */
TargetEntry *
flatCopyTargetEntry(TargetEntry *src_tle)
{
      TargetEntry *tle = makeNode(TargetEntry);

      Assert(IsA(src_tle, TargetEntry));
      memcpy(tle, src_tle, sizeof(TargetEntry));
      return tle;
}

/*
 * makeFromExpr -
 *      creates a FromExpr node
 */
FromExpr *
makeFromExpr(List *fromlist, Node *quals)
{
      FromExpr   *f = makeNode(FromExpr);

      f->fromlist = fromlist;
      f->quals = quals;
      return f;
}

/*
 * makeConst -
 *      creates a Const node
 */
Const *
makeConst(Oid consttype,
              int32 consttypmod,
              int constlen,
              Datum constvalue,
              bool constisnull,
              bool constbyval)
{
      Const    *cnst = makeNode(Const);

      cnst->consttype = consttype;
      cnst->consttypmod = consttypmod;
      cnst->constlen = constlen;
      cnst->constvalue = constvalue;
      cnst->constisnull = constisnull;
      cnst->constbyval = constbyval;
      cnst->location = -1;          /* "unknown" */

      return cnst;
}

/*
 * makeNullConst -
 *      creates a Const node representing a NULL of the specified type/typmod
 *
 * This is a convenience routine that just saves a lookup of the type's
 * storage properties.
 */
Const *
makeNullConst(Oid consttype, int32 consttypmod)
{
      int16       typLen;
      bool        typByVal;

      get_typlenbyval(consttype, &typLen, &typByVal);
      return makeConst(consttype,
                               consttypmod,
                               (int) typLen,
                               (Datum) 0,
                               true,
                               typByVal);
}

/*
 * makeBoolConst -
 *      creates a Const node representing a boolean value (can be NULL too)
 */
Node *
makeBoolConst(bool value, bool isnull)
{
      /* note that pg_type.h hardwires size of bool as 1 ... duplicate it */
      return (Node *) makeConst(BOOLOID, -1, 1,
                                            BoolGetDatum(value), isnull, true);
}

/*
 * makeBoolExpr -
 *      creates a BoolExpr node
 */
Expr *
makeBoolExpr(BoolExprType boolop, List *args, int location)
{
      BoolExpr   *b = makeNode(BoolExpr);

      b->boolop = boolop;
      b->args = args;
      b->location = location;

      return (Expr *) b;
}

/*
 * makeAlias -
 *      creates an Alias node
 *
 * NOTE: the given name is copied, but the colnames list (if any) isn't.
 */
Alias *
makeAlias(const char *aliasname, List *colnames)
{
      Alias    *a = makeNode(Alias);

      a->aliasname = pstrdup(aliasname);
      a->colnames = colnames;

      return a;
}

/*
 * makeRelabelType -
 *      creates a RelabelType node
 */
RelabelType *
makeRelabelType(Expr *arg, Oid rtype, int32 rtypmod, CoercionForm rformat)
{
      RelabelType *r = makeNode(RelabelType);

      r->arg = arg;
      r->resulttype = rtype;
      r->resulttypmod = rtypmod;
      r->relabelformat = rformat;
      r->location = -1;

      return r;
}

/*
 * makeRangeVar -
 *      creates a RangeVar node (rather oversimplified case)
 */
RangeVar *
makeRangeVar(char *schemaname, char *relname, int location)
{
      RangeVar   *r = makeNode(RangeVar);

      r->catalogname = NULL;
      r->schemaname = schemaname;
      r->relname = relname;
      r->inhOpt = INH_DEFAULT;
      r->istemp = false;
      r->alias = NULL;
      r->location = location;

      return r;
}

/*
 * makeTypeName -
 *    build a TypeName node for an unqualified name.
 *
 * typmod is defaulted, but can be changed later by caller.
 */
TypeName *
makeTypeName(char *typnam)
{
      return makeTypeNameFromNameList(list_make1(makeString(typnam)));
}

/*
 * makeTypeNameFromNameList -
 *    build a TypeName node for a String list representing a qualified name.
 *
 * typmod is defaulted, but can be changed later by caller.
 */
TypeName *
makeTypeNameFromNameList(List *names)
{
      TypeName   *n = makeNode(TypeName);

      n->names = names;
      n->typmods = NIL;
      n->typemod = -1;
      n->location = -1;
      return n;
}

/*
 * makeTypeNameFromOid -
 *    build a TypeName node to represent a type already known by OID/typmod.
 */
TypeName *
makeTypeNameFromOid(Oid typeid, int32 typmod)
{
      TypeName   *n = makeNode(TypeName);

      n->typeid = typeid;
      n->typemod = typmod;
      n->location = -1;
      return n;
}

/*
 * makeFuncExpr -
 *    build an expression tree representing a function call.
 *
 * The argument expressions must have been transformed already.
 */
FuncExpr *
makeFuncExpr(Oid funcid, Oid rettype, List *args, CoercionForm fformat)
{
      FuncExpr   *funcexpr;

      funcexpr = makeNode(FuncExpr);
      funcexpr->funcid = funcid;
      funcexpr->funcresulttype = rettype;
      funcexpr->funcretset = false;       /* only allowed case here */
      funcexpr->funcformat = fformat;
      funcexpr->args = args;
      funcexpr->location = -1;

      return funcexpr;
}

/*
 * makeDefElem -
 *    build a DefElem node
 *
 * This is sufficient for the "typical" case with an unqualified option name
 * and no special action.
 */
DefElem *
makeDefElem(char *name, Node *arg)
{
      DefElem    *res = makeNode(DefElem);

      res->defnamespace = NULL;
      res->defname = name;
      res->arg = arg;
      res->defaction = DEFELEM_UNSPEC;

      return res;
}

/*
 * makeDefElemExtended -
 *    build a DefElem node with all fields available to be specified
 */
DefElem *
makeDefElemExtended(char *namespace, char *name, Node *arg,
                              DefElemAction defaction)
{
      DefElem    *res = makeNode(DefElem);

      res->defnamespace = namespace;
      res->defname = name;
      res->arg = arg;
      res->defaction = defaction;

      return res;
}

Generated by  Doxygen 1.6.0   Back to index