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

parse_expr.c

/*-------------------------------------------------------------------------
 *
 * parse_expr.c
 *      handle expressions in parser
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/parser/parse_expr.c,v 1.241 2009/06/11 14:49:00 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/var.h"
#include "parser/analyze.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_oper.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/xml.h"


bool        Transform_null_equals = false;

static Node *transformParamRef(ParseState *pstate, ParamRef *pref);
static Node *transformAExprOp(ParseState *pstate, A_Expr *a);
static Node *transformAExprAnd(ParseState *pstate, A_Expr *a);
static Node *transformAExprOr(ParseState *pstate, A_Expr *a);
static Node *transformAExprNot(ParseState *pstate, A_Expr *a);
static Node *transformAExprOpAny(ParseState *pstate, A_Expr *a);
static Node *transformAExprOpAll(ParseState *pstate, A_Expr *a);
static Node *transformAExprDistinct(ParseState *pstate, A_Expr *a);
static Node *transformAExprNullIf(ParseState *pstate, A_Expr *a);
static Node *transformAExprOf(ParseState *pstate, A_Expr *a);
static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
                           Oid array_type, Oid element_type, int32 typmod);
static Node *transformRowExpr(ParseState *pstate, RowExpr *r);
static Node *transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c);
static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m);
static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
static Node *transformWholeRowRef(ParseState *pstate, char *schemaname,
                               char *relname, int location);
static Node *transformIndirection(ParseState *pstate, Node *basenode,
                               List *indirection);
static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
static Node *make_row_comparison_op(ParseState *pstate, List *opname,
                                 List *largs, List *rargs, int location);
static Node *make_row_distinct_op(ParseState *pstate, List *opname,
                               RowExpr *lrow, RowExpr *rrow, int location);
static Expr *make_distinct_op(ParseState *pstate, List *opname,
                         Node *ltree, Node *rtree, int location);


/*
 * transformExpr -
 *      Analyze and transform expressions. Type checking and type casting is
 *      done here. The optimizer and the executor cannot handle the original
 *      (raw) expressions collected by the parse tree. Hence the transformation
 *      here.
 *
 * NOTE: there are various cases in which this routine will get applied to
 * an already-transformed expression.  Some examples:
 *    1. At least one construct (BETWEEN/AND) puts the same nodes
 *    into two branches of the parse tree; hence, some nodes
 *    are transformed twice.
 *    2. Another way it can happen is that coercion of an operator or
 *    function argument to the required type (via coerce_type())
 *    can apply transformExpr to an already-transformed subexpression.
 *    An example here is "SELECT count(*) + 1.0 FROM table".
 * While it might be possible to eliminate these cases, the path of
 * least resistance so far has been to ensure that transformExpr() does
 * no damage if applied to an already-transformed tree.  This is pretty
 * easy for cases where the transformation replaces one node type with
 * another, such as A_Const => Const; we just do nothing when handed
 * a Const.  More care is needed for node types that are used as both
 * input and output of transformExpr; see SubLink for example.
 */
Node *
transformExpr(ParseState *pstate, Node *expr)
{
      Node     *result = NULL;

      if (expr == NULL)
            return NULL;

      /* Guard against stack overflow due to overly complex expressions */
      check_stack_depth();

      switch (nodeTag(expr))
      {
            case T_ColumnRef:
                  result = transformColumnRef(pstate, (ColumnRef *) expr);
                  break;

            case T_ParamRef:
                  result = transformParamRef(pstate, (ParamRef *) expr);
                  break;

            case T_A_Const:
                  {
                        A_Const    *con = (A_Const *) expr;
                        Value    *val = &con->val;

                        result = (Node *) make_const(pstate, val, con->location);
                        break;
                  }

            case T_A_Indirection:
                  {
                        A_Indirection *ind = (A_Indirection *) expr;

                        result = transformExpr(pstate, ind->arg);
                        result = transformIndirection(pstate, result,
                                                                    ind->indirection);
                        break;
                  }

            case T_A_ArrayExpr:
                  result = transformArrayExpr(pstate, (A_ArrayExpr *) expr,
                                                            InvalidOid, InvalidOid, -1);
                  break;

            case T_TypeCast:
                  {
                        TypeCast   *tc = (TypeCast *) expr;

                        /*
                         * If the subject of the typecast is an ARRAY[] construct and
                         * the target type is an array type, we invoke
                         * transformArrayExpr() directly so that we can pass down the
                         * type information.  This avoids some cases where
                         * transformArrayExpr() might not infer the correct type.
                         */
                        if (IsA(tc->arg, A_ArrayExpr))
                        {
                              Oid               targetType;
                              Oid               elementType;
                              int32       targetTypmod;

                              targetType = typenameTypeId(pstate, tc->typename,
                                                                        &targetTypmod);
                              elementType = get_element_type(targetType);
                              if (OidIsValid(elementType))
                              {
                                    result = transformArrayExpr(pstate,
                                                                              (A_ArrayExpr *) tc->arg,
                                                                              targetType,
                                                                              elementType,
                                                                              targetTypmod);
                                    break;
                              }

                              /*
                               * Corner case: ARRAY[] cast to a non-array type. Fall
                               * through to do it the standard way.
                               */
                        }

                        result = transformTypeCast(pstate, tc);
                        break;
                  }

            case T_A_Expr:
                  {
                        A_Expr         *a = (A_Expr *) expr;

                        switch (a->kind)
                        {
                              case AEXPR_OP:
                                    result = transformAExprOp(pstate, a);
                                    break;
                              case AEXPR_AND:
                                    result = transformAExprAnd(pstate, a);
                                    break;
                              case AEXPR_OR:
                                    result = transformAExprOr(pstate, a);
                                    break;
                              case AEXPR_NOT:
                                    result = transformAExprNot(pstate, a);
                                    break;
                              case AEXPR_OP_ANY:
                                    result = transformAExprOpAny(pstate, a);
                                    break;
                              case AEXPR_OP_ALL:
                                    result = transformAExprOpAll(pstate, a);
                                    break;
                              case AEXPR_DISTINCT:
                                    result = transformAExprDistinct(pstate, a);
                                    break;
                              case AEXPR_NULLIF:
                                    result = transformAExprNullIf(pstate, a);
                                    break;
                              case AEXPR_OF:
                                    result = transformAExprOf(pstate, a);
                                    break;
                              case AEXPR_IN:
                                    result = transformAExprIn(pstate, a);
                                    break;
                              default:
                                    elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
                        }
                        break;
                  }

            case T_FuncCall:
                  result = transformFuncCall(pstate, (FuncCall *) expr);
                  break;

            case T_SubLink:
                  result = transformSubLink(pstate, (SubLink *) expr);
                  break;

            case T_CaseExpr:
                  result = transformCaseExpr(pstate, (CaseExpr *) expr);
                  break;

            case T_RowExpr:
                  result = transformRowExpr(pstate, (RowExpr *) expr);
                  break;

            case T_CoalesceExpr:
                  result = transformCoalesceExpr(pstate, (CoalesceExpr *) expr);
                  break;

            case T_MinMaxExpr:
                  result = transformMinMaxExpr(pstate, (MinMaxExpr *) expr);
                  break;

            case T_XmlExpr:
                  result = transformXmlExpr(pstate, (XmlExpr *) expr);
                  break;

            case T_XmlSerialize:
                  result = transformXmlSerialize(pstate, (XmlSerialize *) expr);
                  break;

            case T_NullTest:
                  {
                        NullTest   *n = (NullTest *) expr;

                        n->arg = (Expr *) transformExpr(pstate, (Node *) n->arg);
                        /* the argument can be any type, so don't coerce it */
                        result = expr;
                        break;
                  }

            case T_BooleanTest:
                  result = transformBooleanTest(pstate, (BooleanTest *) expr);
                  break;

            case T_CurrentOfExpr:
                  result = transformCurrentOfExpr(pstate, (CurrentOfExpr *) expr);
                  break;

                  /*********************************************
                   * Quietly accept node types that may be presented when we are
                   * called on an already-transformed tree.
                   *
                   * Do any other node types need to be accepted?  For now we are
                   * taking a conservative approach, and only accepting node
                   * types that are demonstrably necessary to accept.
                   *********************************************/
            case T_Var:
            case T_Const:
            case T_Param:
            case T_Aggref:
            case T_WindowFunc:
            case T_ArrayRef:
            case T_FuncExpr:
            case T_OpExpr:
            case T_DistinctExpr:
            case T_ScalarArrayOpExpr:
            case T_NullIfExpr:
            case T_BoolExpr:
            case T_FieldSelect:
            case T_FieldStore:
            case T_RelabelType:
            case T_CoerceViaIO:
            case T_ArrayCoerceExpr:
            case T_ConvertRowtypeExpr:
            case T_CaseTestExpr:
            case T_CoerceToDomain:
            case T_CoerceToDomainValue:
            case T_SetToDefault:
                  {
                        result = (Node *) expr;
                        break;
                  }

            default:
                  /* should not reach here */
                  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
                  break;
      }

      return result;
}

static Node *
transformIndirection(ParseState *pstate, Node *basenode, List *indirection)
{
      Node     *result = basenode;
      List     *subscripts = NIL;
      ListCell   *i;

      /*
       * We have to split any field-selection operations apart from
       * subscripting.  Adjacent A_Indices nodes have to be treated as a single
       * multidimensional subscript operation.
       */
      foreach(i, indirection)
      {
            Node     *n = lfirst(i);

            if (IsA(n, A_Indices))
                  subscripts = lappend(subscripts, n);
            else if (IsA(n, A_Star))
            {
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                               errmsg("row expansion via \"*\" is not supported here"),
                               parser_errposition(pstate, exprLocation(basenode))));
            }
            else
            {
                  Assert(IsA(n, String));

                  /* process subscripts before this field selection */
                  if (subscripts)
                        result = (Node *) transformArraySubscripts(pstate,
                                                                                       result,
                                                                                       exprType(result),
                                                                                       InvalidOid,
                                                                                       exprTypmod(result),
                                                                                       subscripts,
                                                                                       NULL);
                  subscripts = NIL;

                  result = ParseFuncOrColumn(pstate,
                                                         list_make1(n),
                                                         list_make1(result),
                                                         false, false, false,
                                                         NULL, true, -1);
            }
      }
      /* process trailing subscripts, if any */
      if (subscripts)
            result = (Node *) transformArraySubscripts(pstate,
                                                                           result,
                                                                           exprType(result),
                                                                           InvalidOid,
                                                                           exprTypmod(result),
                                                                           subscripts,
                                                                           NULL);

      return result;
}

static Node *
transformColumnRef(ParseState *pstate, ColumnRef *cref)
{
      int               numnames = list_length(cref->fields);
      Node     *node;
      int               levels_up;

      /*----------
       * The allowed syntaxes are:
       *
       * A        First try to resolve as unqualified column name;
       *                if no luck, try to resolve as unqualified table name (A.*).
       * A.B            A is an unqualified table name; B is either a
       *                column or function name (trying column name first).
       * A.B.C    schema A, table B, col or func name C.
       * A.B.C.D  catalog A, schema B, table C, col or func D.
       * A.*            A is an unqualified table name; means whole-row value.
       * A.B.*    whole-row value of table B in schema A.
       * A.B.C.*  whole-row value of table C in schema B in catalog A.
       *
       * We do not need to cope with bare "*"; that will only be accepted by
       * the grammar at the top level of a SELECT list, and transformTargetList
       * will take care of it before it ever gets here.  Also, "A.*" etc will
       * be expanded by transformTargetList if they appear at SELECT top level,
       * so here we are only going to see them as function or operator inputs.
       *
       * Currently, if a catalog name is given then it must equal the current
       * database name; we check it here and then discard it.
       *----------
       */
      switch (numnames)
      {
            case 1:
                  {
                        Node     *field1 = (Node *) linitial(cref->fields);
                        char     *name1;

                        Assert(IsA(field1, String));
                        name1 = strVal(field1);

                        /* Try to identify as an unqualified column */
                        node = colNameToVar(pstate, name1, false, cref->location);

                        if (node == NULL)
                        {
                              /*
                               * Not known as a column of any range-table entry.
                               *
                               * Consider the possibility that it's VALUE in a domain
                               * check expression.  (We handle VALUE as a name, not a
                               * keyword, to avoid breaking a lot of applications that
                               * have used VALUE as a column name in the past.)
                               */
                              if (pstate->p_value_substitute != NULL &&
                                    strcmp(name1, "value") == 0)
                              {
                                    node = (Node *) copyObject(pstate->p_value_substitute);

                                    /*
                                     * Try to propagate location knowledge.  This should
                                     * be extended if p_value_substitute can ever take on
                                     * other node types.
                                     */
                                    if (IsA(node, CoerceToDomainValue))
                                          ((CoerceToDomainValue *) node)->location = cref->location;
                                    break;
                              }

                              /*
                               * Try to find the name as a relation.    Note that only
                               * relations already entered into the rangetable will be
                               * recognized.
                               *
                               * This is a hack for backwards compatibility with
                               * PostQUEL-inspired syntax.  The preferred form now is
                               * "rel.*".
                               */
                              if (refnameRangeTblEntry(pstate, NULL, name1,
                                                                   cref->location,
                                                                   &levels_up) != NULL)
                                    node = transformWholeRowRef(pstate, NULL, name1,
                                                                              cref->location);
                              else
                                    ereport(ERROR,
                                                (errcode(ERRCODE_UNDEFINED_COLUMN),
                                                 errmsg("column \"%s\" does not exist",
                                                            name1),
                                                 parser_errposition(pstate, cref->location)));
                        }
                        break;
                  }
            case 2:
                  {
                        Node     *field1 = (Node *) linitial(cref->fields);
                        Node     *field2 = (Node *) lsecond(cref->fields);
                        char     *name1;
                        char     *name2;

                        Assert(IsA(field1, String));
                        name1 = strVal(field1);

                        /* Whole-row reference? */
                        if (IsA(field2, A_Star))
                        {
                              node = transformWholeRowRef(pstate, NULL, name1,
                                                                        cref->location);
                              break;
                        }

                        Assert(IsA(field2, String));
                        name2 = strVal(field2);

                        /* Try to identify as a once-qualified column */
                        node = qualifiedNameToVar(pstate, NULL, name1, name2, true,
                                                              cref->location);
                        if (node == NULL)
                        {
                              /*
                               * Not known as a column of any range-table entry, so try
                               * it as a function call.  Here, we will create an
                               * implicit RTE for tables not already entered.
                               */
                              node = transformWholeRowRef(pstate, NULL, name1,
                                                                        cref->location);
                              node = ParseFuncOrColumn(pstate,
                                                                   list_make1(makeString(name2)),
                                                                   list_make1(node),
                                                                   false, false, false,
                                                                   NULL, true, cref->location);
                        }
                        break;
                  }
            case 3:
                  {
                        Node     *field1 = (Node *) linitial(cref->fields);
                        Node     *field2 = (Node *) lsecond(cref->fields);
                        Node     *field3 = (Node *) lthird(cref->fields);
                        char     *name1;
                        char     *name2;
                        char     *name3;

                        Assert(IsA(field1, String));
                        name1 = strVal(field1);
                        Assert(IsA(field2, String));
                        name2 = strVal(field2);

                        /* Whole-row reference? */
                        if (IsA(field3, A_Star))
                        {
                              node = transformWholeRowRef(pstate, name1, name2,
                                                                        cref->location);
                              break;
                        }

                        Assert(IsA(field3, String));
                        name3 = strVal(field3);

                        /* Try to identify as a twice-qualified column */
                        node = qualifiedNameToVar(pstate, name1, name2, name3, true,
                                                              cref->location);
                        if (node == NULL)
                        {
                              /* Try it as a function call */
                              node = transformWholeRowRef(pstate, name1, name2,
                                                                        cref->location);
                              node = ParseFuncOrColumn(pstate,
                                                                   list_make1(makeString(name3)),
                                                                   list_make1(node),
                                                                   false, false, false,
                                                                   NULL, true, cref->location);
                        }
                        break;
                  }
            case 4:
                  {
                        Node     *field1 = (Node *) linitial(cref->fields);
                        Node     *field2 = (Node *) lsecond(cref->fields);
                        Node     *field3 = (Node *) lthird(cref->fields);
                        Node     *field4 = (Node *) lfourth(cref->fields);
                        char     *name1;
                        char     *name2;
                        char     *name3;
                        char     *name4;

                        Assert(IsA(field1, String));
                        name1 = strVal(field1);
                        Assert(IsA(field2, String));
                        name2 = strVal(field2);
                        Assert(IsA(field3, String));
                        name3 = strVal(field3);

                        /*
                         * We check the catalog name and then ignore it.
                         */
                        if (strcmp(name1, get_database_name(MyDatabaseId)) != 0)
                              ereport(ERROR,
                                          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                                           errmsg("cross-database references are not implemented: %s",
                                                      NameListToString(cref->fields)),
                                           parser_errposition(pstate, cref->location)));

                        /* Whole-row reference? */
                        if (IsA(field4, A_Star))
                        {
                              node = transformWholeRowRef(pstate, name2, name3,
                                                                        cref->location);
                              break;
                        }

                        Assert(IsA(field4, String));
                        name4 = strVal(field4);

                        /* Try to identify as a twice-qualified column */
                        node = qualifiedNameToVar(pstate, name2, name3, name4, true,
                                                              cref->location);
                        if (node == NULL)
                        {
                              /* Try it as a function call */
                              node = transformWholeRowRef(pstate, name2, name3,
                                                                        cref->location);
                              node = ParseFuncOrColumn(pstate,
                                                                   list_make1(makeString(name4)),
                                                                   list_make1(node),
                                                                   false, false, false,
                                                                   NULL, true, cref->location);
                        }
                        break;
                  }
            default:
                  ereport(ERROR,
                              (errcode(ERRCODE_SYNTAX_ERROR),
                        errmsg("improper qualified name (too many dotted names): %s",
                                 NameListToString(cref->fields)),
                               parser_errposition(pstate, cref->location)));
                  node = NULL;            /* keep compiler quiet */
                  break;
      }

      return node;
}

/*
 * Locate the parameter type info for the given parameter number, and
 * return a pointer to it.
 */
static Oid *
find_param_type(ParseState *pstate, int paramno, int location)
{
      Oid            *result;

      /*
       * Find topmost ParseState, which is where paramtype info lives.
       */
      while (pstate->parentParseState != NULL)
            pstate = pstate->parentParseState;

      /* Check parameter number is in range */
      if (paramno <= 0)             /* probably can't happen? */
            ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_PARAMETER),
                         errmsg("there is no parameter $%d", paramno),
                         parser_errposition(pstate, location)));
      if (paramno > pstate->p_numparams)
      {
            if (!pstate->p_variableparams)
                  ereport(ERROR,
                              (errcode(ERRCODE_UNDEFINED_PARAMETER),
                               errmsg("there is no parameter $%d", paramno),
                               parser_errposition(pstate, location)));
            /* Okay to enlarge param array */
            if (pstate->p_paramtypes)
                  pstate->p_paramtypes = (Oid *) repalloc(pstate->p_paramtypes,
                                                                              paramno * sizeof(Oid));
            else
                  pstate->p_paramtypes = (Oid *) palloc(paramno * sizeof(Oid));
            /* Zero out the previously-unreferenced slots */
            MemSet(pstate->p_paramtypes + pstate->p_numparams,
                     0,
                     (paramno - pstate->p_numparams) * sizeof(Oid));
            pstate->p_numparams = paramno;
      }

      result = &pstate->p_paramtypes[paramno - 1];

      if (pstate->p_variableparams)
      {
            /* If not seen before, initialize to UNKNOWN type */
            if (*result == InvalidOid)
                  *result = UNKNOWNOID;
      }

      return result;
}

static Node *
transformParamRef(ParseState *pstate, ParamRef *pref)
{
      int               paramno = pref->number;
      Oid            *pptype = find_param_type(pstate, paramno, pref->location);
      Param    *param;

      param = makeNode(Param);
      param->paramkind = PARAM_EXTERN;
      param->paramid = paramno;
      param->paramtype = *pptype;
      param->paramtypmod = -1;
      param->location = pref->location;

      return (Node *) param;
}

/* Test whether an a_expr is a plain NULL constant or not */
static bool
exprIsNullConstant(Node *arg)
{
      if (arg && IsA(arg, A_Const))
      {
            A_Const    *con = (A_Const *) arg;

            if (con->val.type == T_Null)
                  return true;
      }
      return false;
}

static Node *
transformAExprOp(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = a->lexpr;
      Node     *rexpr = a->rexpr;
      Node     *result;

      /*
       * Special-case "foo = NULL" and "NULL = foo" for compatibility with
       * standards-broken products (like Microsoft's).  Turn these into IS NULL
       * exprs.
       */
      if (Transform_null_equals &&
            list_length(a->name) == 1 &&
            strcmp(strVal(linitial(a->name)), "=") == 0 &&
            (exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)))
      {
            NullTest   *n = makeNode(NullTest);

            n->nulltesttype = IS_NULL;

            if (exprIsNullConstant(lexpr))
                  n->arg = (Expr *) rexpr;
            else
                  n->arg = (Expr *) lexpr;

            result = transformExpr(pstate, (Node *) n);
      }
      else if (lexpr && IsA(lexpr, RowExpr) &&
                   rexpr && IsA(rexpr, SubLink) &&
                   ((SubLink *) rexpr)->subLinkType == EXPR_SUBLINK)
      {
            /*
             * Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the
             * grammar did this, but now that a row construct is allowed anywhere
             * in expressions, it's easier to do it here.
             */
            SubLink    *s = (SubLink *) rexpr;

            s->subLinkType = ROWCOMPARE_SUBLINK;
            s->testexpr = lexpr;
            s->operName = a->name;
            s->location = a->location;
            result = transformExpr(pstate, (Node *) s);
      }
      else if (lexpr && IsA(lexpr, RowExpr) &&
                   rexpr && IsA(rexpr, RowExpr))
      {
            /* "row op row" */
            lexpr = transformExpr(pstate, lexpr);
            rexpr = transformExpr(pstate, rexpr);
            Assert(IsA(lexpr, RowExpr));
            Assert(IsA(rexpr, RowExpr));

            result = make_row_comparison_op(pstate,
                                                            a->name,
                                                            ((RowExpr *) lexpr)->args,
                                                            ((RowExpr *) rexpr)->args,
                                                            a->location);
      }
      else
      {
            /* Ordinary scalar operator */
            lexpr = transformExpr(pstate, lexpr);
            rexpr = transformExpr(pstate, rexpr);

            result = (Node *) make_op(pstate,
                                                  a->name,
                                                  lexpr,
                                                  rexpr,
                                                  a->location);
      }

      return result;
}

static Node *
transformAExprAnd(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      lexpr = coerce_to_boolean(pstate, lexpr, "AND");
      rexpr = coerce_to_boolean(pstate, rexpr, "AND");

      return (Node *) makeBoolExpr(AND_EXPR,
                                                 list_make2(lexpr, rexpr),
                                                 a->location);
}

static Node *
transformAExprOr(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      lexpr = coerce_to_boolean(pstate, lexpr, "OR");
      rexpr = coerce_to_boolean(pstate, rexpr, "OR");

      return (Node *) makeBoolExpr(OR_EXPR,
                                                 list_make2(lexpr, rexpr),
                                                 a->location);
}

static Node *
transformAExprNot(ParseState *pstate, A_Expr *a)
{
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      rexpr = coerce_to_boolean(pstate, rexpr, "NOT");

      return (Node *) makeBoolExpr(NOT_EXPR,
                                                 list_make1(rexpr),
                                                 a->location);
}

static Node *
transformAExprOpAny(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      return (Node *) make_scalar_array_op(pstate,
                                                             a->name,
                                                             true,
                                                             lexpr,
                                                             rexpr,
                                                             a->location);
}

static Node *
transformAExprOpAll(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      return (Node *) make_scalar_array_op(pstate,
                                                             a->name,
                                                             false,
                                                             lexpr,
                                                             rexpr,
                                                             a->location);
}

static Node *
transformAExprDistinct(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);

      if (lexpr && IsA(lexpr, RowExpr) &&
            rexpr && IsA(rexpr, RowExpr))
      {
            /* "row op row" */
            return make_row_distinct_op(pstate, a->name,
                                                      (RowExpr *) lexpr,
                                                      (RowExpr *) rexpr,
                                                      a->location);
      }
      else
      {
            /* Ordinary scalar operator */
            return (Node *) make_distinct_op(pstate,
                                                             a->name,
                                                             lexpr,
                                                             rexpr,
                                                             a->location);
      }
}

static Node *
transformAExprNullIf(ParseState *pstate, A_Expr *a)
{
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Node     *rexpr = transformExpr(pstate, a->rexpr);
      Node     *result;

      result = (Node *) make_op(pstate,
                                            a->name,
                                            lexpr,
                                            rexpr,
                                            a->location);
      if (((OpExpr *) result)->opresulttype != BOOLOID)
            ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("NULLIF requires = operator to yield boolean"),
                         parser_errposition(pstate, a->location)));

      /*
       * We rely on NullIfExpr and OpExpr being the same struct
       */
      NodeSetTag(result, T_NullIfExpr);

      return result;
}

static Node *
transformAExprOf(ParseState *pstate, A_Expr *a)
{
      /*
       * Checking an expression for match to a list of type names. Will result
       * in a boolean constant node.
       */
      Node     *lexpr = transformExpr(pstate, a->lexpr);
      Const    *result;
      ListCell   *telem;
      Oid               ltype,
                        rtype;
      bool        matched = false;

      ltype = exprType(lexpr);
      foreach(telem, (List *) a->rexpr)
      {
            rtype = typenameTypeId(pstate, lfirst(telem), NULL);
            matched = (rtype == ltype);
            if (matched)
                  break;
      }

      /*
       * We have two forms: equals or not equals. Flip the sense of the result
       * for not equals.
       */
      if (strcmp(strVal(linitial(a->name)), "<>") == 0)
            matched = (!matched);

      result = (Const *) makeBoolConst(matched, false);

      /* Make the result have the original input's parse location */
      result->location = exprLocation((Node *) a);

      return (Node *) result;
}

static Node *
transformAExprIn(ParseState *pstate, A_Expr *a)
{
      Node     *result = NULL;
      Node     *lexpr;
      List     *rexprs;
      List     *rvars;
      List     *rnonvars;
      bool        useOr;
      bool        haveRowExpr;
      ListCell   *l;

      /*
       * If the operator is <>, combine with AND not OR.
       */
      if (strcmp(strVal(linitial(a->name)), "<>") == 0)
            useOr = false;
      else
            useOr = true;

      /*
       * We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
       * possible if the inputs are all scalars (no RowExprs) and there is a
       * suitable array type available.  If not, we fall back to a boolean
       * condition tree with multiple copies of the lefthand expression. Also,
       * any IN-list items that contain Vars are handled as separate boolean
       * conditions, because that gives the planner more scope for optimization
       * on such clauses.
       *
       * First step: transform all the inputs, and detect whether any are
       * RowExprs or contain Vars.
       */
      lexpr = transformExpr(pstate, a->lexpr);
      haveRowExpr = (lexpr && IsA(lexpr, RowExpr));
      rexprs = rvars = rnonvars = NIL;
      foreach(l, (List *) a->rexpr)
      {
            Node     *rexpr = transformExpr(pstate, lfirst(l));

            haveRowExpr |= (rexpr && IsA(rexpr, RowExpr));
            rexprs = lappend(rexprs, rexpr);
            if (contain_vars_of_level(rexpr, 0))
                  rvars = lappend(rvars, rexpr);
            else
                  rnonvars = lappend(rnonvars, rexpr);
      }

      /*
       * ScalarArrayOpExpr is only going to be useful if there's more than one
       * non-Var righthand item.    Also, it won't work for RowExprs.
       */
      if (!haveRowExpr && list_length(rnonvars) > 1)
      {
            List     *allexprs;
            Oid               scalar_type;
            Oid               array_type;

            /*
             * Try to select a common type for the array elements.      Note that
             * since the LHS' type is first in the list, it will be preferred when
             * there is doubt (eg, when all the RHS items are unknown literals).
             *
             * Note: use list_concat here not lcons, to avoid damaging rnonvars.
             */
            allexprs = list_concat(list_make1(lexpr), rnonvars);
            scalar_type = select_common_type(pstate, allexprs, NULL, NULL);

            /* Do we have an array type to use? */
            if (OidIsValid(scalar_type))
                  array_type = get_array_type(scalar_type);
            else
                  array_type = InvalidOid;
            if (array_type != InvalidOid)
            {
                  /*
                   * OK: coerce all the right-hand non-Var inputs to the common type
                   * and build an ArrayExpr for them.
                   */
                  List     *aexprs;
                  ArrayExpr  *newa;

                  aexprs = NIL;
                  foreach(l, rnonvars)
                  {
                        Node     *rexpr = (Node *) lfirst(l);

                        rexpr = coerce_to_common_type(pstate, rexpr,
                                                                    scalar_type,
                                                                    "IN");
                        aexprs = lappend(aexprs, rexpr);
                  }
                  newa = makeNode(ArrayExpr);
                  newa->array_typeid = array_type;
                  newa->element_typeid = scalar_type;
                  newa->elements = aexprs;
                  newa->multidims = false;
                  newa->location = -1;

                  result = (Node *) make_scalar_array_op(pstate,
                                                                           a->name,
                                                                           useOr,
                                                                           lexpr,
                                                                           (Node *) newa,
                                                                           a->location);

                  /* Consider only the Vars (if any) in the loop below */
                  rexprs = rvars;
            }
      }

      /*
       * Must do it the hard way, ie, with a boolean expression tree.
       */
      foreach(l, rexprs)
      {
            Node     *rexpr = (Node *) lfirst(l);
            Node     *cmp;

            if (haveRowExpr)
            {
                  if (!IsA(lexpr, RowExpr) ||
                        !IsA(rexpr, RowExpr))
                        ereport(ERROR,
                                    (errcode(ERRCODE_SYNTAX_ERROR),
                           errmsg("arguments of row IN must all be row expressions"),
                                     parser_errposition(pstate, a->location)));
                  cmp = make_row_comparison_op(pstate,
                                                             a->name,
                                            (List *) copyObject(((RowExpr *) lexpr)->args),
                                                             ((RowExpr *) rexpr)->args,
                                                             a->location);
            }
            else
                  cmp = (Node *) make_op(pstate,
                                                   a->name,
                                                   copyObject(lexpr),
                                                   rexpr,
                                                   a->location);

            cmp = coerce_to_boolean(pstate, cmp, "IN");
            if (result == NULL)
                  result = cmp;
            else
                  result = (Node *) makeBoolExpr(useOr ? OR_EXPR : AND_EXPR,
                                                               list_make2(result, cmp),
                                                               a->location);
      }

      return result;
}

static Node *
transformFuncCall(ParseState *pstate, FuncCall *fn)
{
      List     *targs;
      ListCell   *args;

      /* Transform the list of arguments ... */
      targs = NIL;
      foreach(args, fn->args)
      {
            targs = lappend(targs, transformExpr(pstate,
                                                                   (Node *) lfirst(args)));
      }

      /* ... and hand off to ParseFuncOrColumn */
      return ParseFuncOrColumn(pstate,
                                           fn->funcname,
                                           targs,
                                           fn->agg_star,
                                           fn->agg_distinct,
                                           fn->func_variadic,
                                           fn->over,
                                           false,
                                           fn->location);
}

static Node *
transformCaseExpr(ParseState *pstate, CaseExpr *c)
{
      CaseExpr   *newc;
      Node     *arg;
      CaseTestExpr *placeholder;
      List     *newargs;
      List     *resultexprs;
      ListCell   *l;
      Node     *defresult;
      Oid               ptype;

      /* If we already transformed this node, do nothing */
      if (OidIsValid(c->casetype))
            return (Node *) c;

      newc = makeNode(CaseExpr);

      /* transform the test expression, if any */
      arg = transformExpr(pstate, (Node *) c->arg);

      /* generate placeholder for test expression */
      if (arg)
      {
            /*
             * If test expression is an untyped literal, force it to text. We have
             * to do something now because we won't be able to do this coercion on
             * the placeholder.  This is not as flexible as what was done in 7.4
             * and before, but it's good enough to handle the sort of silly coding
             * commonly seen.
             */
            if (exprType(arg) == UNKNOWNOID)
                  arg = coerce_to_common_type(pstate, arg, TEXTOID, "CASE");

            placeholder = makeNode(CaseTestExpr);
            placeholder->typeId = exprType(arg);
            placeholder->typeMod = exprTypmod(arg);
      }
      else
            placeholder = NULL;

      newc->arg = (Expr *) arg;

      /* transform the list of arguments */
      newargs = NIL;
      resultexprs = NIL;
      foreach(l, c->args)
      {
            CaseWhen   *w = (CaseWhen *) lfirst(l);
            CaseWhen   *neww = makeNode(CaseWhen);
            Node     *warg;

            Assert(IsA(w, CaseWhen));

            warg = (Node *) w->expr;
            if (placeholder)
            {
                  /* shorthand form was specified, so expand... */
                  warg = (Node *) makeSimpleA_Expr(AEXPR_OP, "=",
                                                                   (Node *) placeholder,
                                                                   warg,
                                                                   w->location);
            }
            neww->expr = (Expr *) transformExpr(pstate, warg);

            neww->expr = (Expr *) coerce_to_boolean(pstate,
                                                                        (Node *) neww->expr,
                                                                        "CASE/WHEN");

            warg = (Node *) w->result;
            neww->result = (Expr *) transformExpr(pstate, warg);
            neww->location = w->location;

            newargs = lappend(newargs, neww);
            resultexprs = lappend(resultexprs, neww->result);
      }

      newc->args = newargs;

      /* transform the default clause */
      defresult = (Node *) c->defresult;
      if (defresult == NULL)
      {
            A_Const    *n = makeNode(A_Const);

            n->val.type = T_Null;
            n->location = -1;
            defresult = (Node *) n;
      }
      newc->defresult = (Expr *) transformExpr(pstate, defresult);

      /*
       * Note: default result is considered the most significant type in
       * determining preferred type. This is how the code worked before, but it
       * seems a little bogus to me --- tgl
       */
      resultexprs = lcons(newc->defresult, resultexprs);

      ptype = select_common_type(pstate, resultexprs, "CASE", NULL);
      Assert(OidIsValid(ptype));
      newc->casetype = ptype;

      /* Convert default result clause, if necessary */
      newc->defresult = (Expr *)
            coerce_to_common_type(pstate,
                                            (Node *) newc->defresult,
                                            ptype,
                                            "CASE/ELSE");

      /* Convert when-clause results, if necessary */
      foreach(l, newc->args)
      {
            CaseWhen   *w = (CaseWhen *) lfirst(l);

            w->result = (Expr *)
                  coerce_to_common_type(pstate,
                                                  (Node *) w->result,
                                                  ptype,
                                                  "CASE/WHEN");
      }

      newc->location = c->location;

      return (Node *) newc;
}

static Node *
transformSubLink(ParseState *pstate, SubLink *sublink)
{
      Node     *result = (Node *) sublink;
      Query    *qtree;

      /* If we already transformed this node, do nothing */
      if (IsA(sublink->subselect, Query))
            return result;

      pstate->p_hasSubLinks = true;
      qtree = parse_sub_analyze(sublink->subselect, pstate);

      /*
       * Check that we got something reasonable.      Many of these conditions are
       * impossible given restrictions of the grammar, but check 'em anyway.
       */
      if (!IsA(qtree, Query) ||
            qtree->commandType != CMD_SELECT ||
            qtree->utilityStmt != NULL)
            elog(ERROR, "unexpected non-SELECT command in SubLink");
      if (qtree->intoClause)
            ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("subquery cannot have SELECT INTO"),
                         parser_errposition(pstate,
                                                 exprLocation((Node *) qtree->intoClause))));

      sublink->subselect = (Node *) qtree;

      if (sublink->subLinkType == EXISTS_SUBLINK)
      {
            /*
             * EXISTS needs no test expression or combining operator. These fields
             * should be null already, but make sure.
             */
            sublink->testexpr = NULL;
            sublink->operName = NIL;
      }
      else if (sublink->subLinkType == EXPR_SUBLINK ||
                   sublink->subLinkType == ARRAY_SUBLINK)
      {
            ListCell   *tlist_item = list_head(qtree->targetList);

            /*
             * Make sure the subselect delivers a single column (ignoring resjunk
             * targets).
             */
            if (tlist_item == NULL ||
                  ((TargetEntry *) lfirst(tlist_item))->resjunk)
                  ereport(ERROR,
                              (errcode(ERRCODE_SYNTAX_ERROR),
                               errmsg("subquery must return a column"),
                               parser_errposition(pstate, sublink->location)));
            while ((tlist_item = lnext(tlist_item)) != NULL)
            {
                  if (!((TargetEntry *) lfirst(tlist_item))->resjunk)
                        ereport(ERROR,
                                    (errcode(ERRCODE_SYNTAX_ERROR),
                                     errmsg("subquery must return only one column"),
                                     parser_errposition(pstate, sublink->location)));
            }

            /*
             * EXPR and ARRAY need no test expression or combining operator. These
             * fields should be null already, but make sure.
             */
            sublink->testexpr = NULL;
            sublink->operName = NIL;
      }
      else
      {
            /* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */
            Node     *lefthand;
            List     *left_list;
            List     *right_list;
            ListCell   *l;

            /*
             * Transform lefthand expression, and convert to a list
             */
            lefthand = transformExpr(pstate, sublink->testexpr);
            if (lefthand && IsA(lefthand, RowExpr))
                  left_list = ((RowExpr *) lefthand)->args;
            else
                  left_list = list_make1(lefthand);

            /*
             * Build a list of PARAM_SUBLINK nodes representing the output columns
             * of the subquery.
             */
            right_list = NIL;
            foreach(l, qtree->targetList)
            {
                  TargetEntry *tent = (TargetEntry *) lfirst(l);
                  Param    *param;

                  if (tent->resjunk)
                        continue;

                  param = makeNode(Param);
                  param->paramkind = PARAM_SUBLINK;
                  param->paramid = tent->resno;
                  param->paramtype = exprType((Node *) tent->expr);
                  param->paramtypmod = exprTypmod((Node *) tent->expr);
                  param->location = -1;

                  right_list = lappend(right_list, param);
            }

            /*
             * We could rely on make_row_comparison_op to complain if the list
             * lengths differ, but we prefer to generate a more specific error
             * message.
             */
            if (list_length(left_list) < list_length(right_list))
                  ereport(ERROR,
                              (errcode(ERRCODE_SYNTAX_ERROR),
                               errmsg("subquery has too many columns"),
                               parser_errposition(pstate, sublink->location)));
            if (list_length(left_list) > list_length(right_list))
                  ereport(ERROR,
                              (errcode(ERRCODE_SYNTAX_ERROR),
                               errmsg("subquery has too few columns"),
                               parser_errposition(pstate, sublink->location)));

            /*
             * Identify the combining operator(s) and generate a suitable
             * row-comparison expression.
             */
            sublink->testexpr = make_row_comparison_op(pstate,
                                                                           sublink->operName,
                                                                           left_list,
                                                                           right_list,
                                                                           sublink->location);
      }

      return result;
}

/*
 * transformArrayExpr
 *
 * If the caller specifies the target type, the resulting array will
 * be of exactly that type.  Otherwise we try to infer a common type
 * for the elements using select_common_type().
 */
static Node *
transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
                           Oid array_type, Oid element_type, int32 typmod)
{
      ArrayExpr  *newa = makeNode(ArrayExpr);
      List     *newelems = NIL;
      List     *newcoercedelems = NIL;
      ListCell   *element;
      Oid               coerce_type;
      bool        coerce_hard;

      /*
       * Transform the element expressions
       *
       * Assume that the array is one-dimensional unless we find an array-type
       * element expression.
       */
      newa->multidims = false;
      foreach(element, a->elements)
      {
            Node     *e = (Node *) lfirst(element);
            Node     *newe;

            /*
             * If an element is itself an A_ArrayExpr, recurse directly so that we
             * can pass down any target type we were given.
             */
            if (IsA(e, A_ArrayExpr))
            {
                  newe = transformArrayExpr(pstate,
                                                        (A_ArrayExpr *) e,
                                                        array_type,
                                                        element_type,
                                                        typmod);
                  /* we certainly have an array here */
                  Assert(array_type == InvalidOid || array_type == exprType(newe));
                  newa->multidims = true;
            }
            else
            {
                  newe = transformExpr(pstate, e);

                  /*
                   * Check for sub-array expressions, if we haven't already found
                   * one.
                   */
                  if (!newa->multidims && type_is_array(exprType(newe)))
                        newa->multidims = true;
            }

            newelems = lappend(newelems, newe);
      }

      /*
       * Select a target type for the elements.
       *
       * If we haven't been given a target array type, we must try to deduce a
       * common type based on the types of the individual elements present.
       */
      if (OidIsValid(array_type))
      {
            /* Caller must ensure array_type matches element_type */
            Assert(OidIsValid(element_type));
            coerce_type = (newa->multidims ? array_type : element_type);
            coerce_hard = true;
      }
      else
      {
            /* Can't handle an empty array without a target type */
            if (newelems == NIL)
                  ereport(ERROR,
                              (errcode(ERRCODE_INDETERMINATE_DATATYPE),
                               errmsg("cannot determine type of empty array"),
                               errhint("Explicitly cast to the desired type, "
                                           "for example ARRAY[]::integer[]."),
                               parser_errposition(pstate, a->location)));

            /* Select a common type for the elements */
            coerce_type = select_common_type(pstate, newelems, "ARRAY", NULL);

            if (newa->multidims)
            {
                  array_type = coerce_type;
                  element_type = get_element_type(array_type);
                  if (!OidIsValid(element_type))
                        ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                                 errmsg("could not find element type for data type %s",
                                            format_type_be(array_type)),
                                     parser_errposition(pstate, a->location)));
            }
            else
            {
                  element_type = coerce_type;
                  array_type = get_array_type(element_type);
                  if (!OidIsValid(array_type))
                        ereport(ERROR,
                                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                                     errmsg("could not find array type for data type %s",
                                                format_type_be(element_type)),
                                     parser_errposition(pstate, a->location)));
            }
            coerce_hard = false;
      }

      /*
       * Coerce elements to target type
       *
       * If the array has been explicitly cast, then the elements are in turn
       * explicitly coerced.
       *
       * If the array's type was merely derived from the common type of its
       * elements, then the elements are implicitly coerced to the common type.
       * This is consistent with other uses of select_common_type().
       */
      foreach(element, newelems)
      {
            Node     *e = (Node *) lfirst(element);
            Node     *newe;

            if (coerce_hard)
            {
                  newe = coerce_to_target_type(pstate, e,
                                                             exprType(e),
                                                             coerce_type,
                                                             typmod,
                                                             COERCION_EXPLICIT,
                                                             COERCE_EXPLICIT_CAST,
                                                             -1);
                  if (newe == NULL)
                        ereport(ERROR,
                                    (errcode(ERRCODE_CANNOT_COERCE),
                                     errmsg("cannot cast type %s to %s",
                                                format_type_be(exprType(e)),
                                                format_type_be(coerce_type)),
                                     parser_errposition(pstate, exprLocation(e))));
            }
            else
                  newe = coerce_to_common_type(pstate, e,
                                                             coerce_type,
                                                             "ARRAY");
            newcoercedelems = lappend(newcoercedelems, newe);
      }

      newa->array_typeid = array_type;
      newa->element_typeid = element_type;
      newa->elements = newcoercedelems;
      newa->location = a->location;

      return (Node *) newa;
}

static Node *
transformRowExpr(ParseState *pstate, RowExpr *r)
{
      RowExpr    *newr = makeNode(RowExpr);

      /* Transform the field expressions */
      newr->args = transformExpressionList(pstate, r->args);

      /* Barring later casting, we consider the type RECORD */
      newr->row_typeid = RECORDOID;
      newr->row_format = COERCE_IMPLICIT_CAST;
      newr->colnames = NIL;         /* ROW() has anonymous columns */
      newr->location = r->location;

      return (Node *) newr;
}

static Node *
transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c)
{
      CoalesceExpr *newc = makeNode(CoalesceExpr);
      List     *newargs = NIL;
      List     *newcoercedargs = NIL;
      ListCell   *args;

      foreach(args, c->args)
      {
            Node     *e = (Node *) lfirst(args);
            Node     *newe;

            newe = transformExpr(pstate, e);
            newargs = lappend(newargs, newe);
      }

      newc->coalescetype = select_common_type(pstate, newargs, "COALESCE", NULL);

      /* Convert arguments if necessary */
      foreach(args, newargs)
      {
            Node     *e = (Node *) lfirst(args);
            Node     *newe;

            newe = coerce_to_common_type(pstate, e,
                                                       newc->coalescetype,
                                                       "COALESCE");
            newcoercedargs = lappend(newcoercedargs, newe);
      }

      newc->args = newcoercedargs;
      newc->location = c->location;
      return (Node *) newc;
}

static Node *
transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m)
{
      MinMaxExpr *newm = makeNode(MinMaxExpr);
      List     *newargs = NIL;
      List     *newcoercedargs = NIL;
      const char *funcname = (m->op == IS_GREATEST) ? "GREATEST" : "LEAST";
      ListCell   *args;

      newm->op = m->op;
      foreach(args, m->args)
      {
            Node     *e = (Node *) lfirst(args);
            Node     *newe;

            newe = transformExpr(pstate, e);
            newargs = lappend(newargs, newe);
      }

      newm->minmaxtype = select_common_type(pstate, newargs, funcname, NULL);

      /* Convert arguments if necessary */
      foreach(args, newargs)
      {
            Node     *e = (Node *) lfirst(args);
            Node     *newe;

            newe = coerce_to_common_type(pstate, e,
                                                       newm->minmaxtype,
                                                       funcname);
            newcoercedargs = lappend(newcoercedargs, newe);
      }

      newm->args = newcoercedargs;
      newm->location = m->location;
      return (Node *) newm;
}

static Node *
transformXmlExpr(ParseState *pstate, XmlExpr *x)
{
      XmlExpr    *newx = makeNode(XmlExpr);
      ListCell   *lc;
      int               i;

      newx->op = x->op;
      if (x->name)
            newx->name = map_sql_identifier_to_xml_name(x->name, false, false);
      else
            newx->name = NULL;
      newx->xmloption = x->xmloption;
      newx->location = x->location;

      /*
       * gram.y built the named args as a list of ResTarget.      Transform each,
       * and break the names out as a separate list.
       */
      newx->named_args = NIL;
      newx->arg_names = NIL;

      foreach(lc, x->named_args)
      {
            ResTarget  *r = (ResTarget *) lfirst(lc);
            Node     *expr;
            char     *argname;

            Assert(IsA(r, ResTarget));

            expr = transformExpr(pstate, r->val);

            if (r->name)
                  argname = map_sql_identifier_to_xml_name(r->name, false, false);
            else if (IsA(r->val, ColumnRef))
                  argname = map_sql_identifier_to_xml_name(FigureColname(r->val),
                                                                               true, false);
            else
            {
                  ereport(ERROR,
                              (errcode(ERRCODE_SYNTAX_ERROR),
                               x->op == IS_XMLELEMENT
                  ? errmsg("unnamed XML attribute value must be a column reference")
                  : errmsg("unnamed XML element value must be a column reference"),
                               parser_errposition(pstate, r->location)));
                  argname = NULL;         /* keep compiler quiet */
            }

            /* reject duplicate argnames in XMLELEMENT only */
            if (x->op == IS_XMLELEMENT)
            {
                  ListCell   *lc2;

                  foreach(lc2, newx->arg_names)
                  {
                        if (strcmp(argname, strVal(lfirst(lc2))) == 0)
                              ereport(ERROR,
                                          (errcode(ERRCODE_SYNTAX_ERROR),
                              errmsg("XML attribute name \"%s\" appears more than once",
                                       argname),
                                           parser_errposition(pstate, r->location)));
                  }
            }

            newx->named_args = lappend(newx->named_args, expr);
            newx->arg_names = lappend(newx->arg_names, makeString(argname));
      }

      /* The other arguments are of varying types depending on the function */
      newx->args = NIL;
      i = 0;
      foreach(lc, x->args)
      {
            Node     *e = (Node *) lfirst(lc);
            Node     *newe;

            newe = transformExpr(pstate, e);
            switch (x->op)
            {
                  case IS_XMLCONCAT:
                        newe = coerce_to_specific_type(pstate, newe, XMLOID,
                                                                     "XMLCONCAT");
                        break;
                  case IS_XMLELEMENT:
                        /* no coercion necessary */
                        break;
                  case IS_XMLFOREST:
                        newe = coerce_to_specific_type(pstate, newe, XMLOID,
                                                                     "XMLFOREST");
                        break;
                  case IS_XMLPARSE:
                        if (i == 0)
                              newe = coerce_to_specific_type(pstate, newe, TEXTOID,
                                                                           "XMLPARSE");
                        else
                              newe = coerce_to_boolean(pstate, newe, "XMLPARSE");
                        break;
                  case IS_XMLPI:
                        newe = coerce_to_specific_type(pstate, newe, TEXTOID,
                                                                     "XMLPI");
                        break;
                  case IS_XMLROOT:
                        if (i == 0)
                              newe = coerce_to_specific_type(pstate, newe, XMLOID,
                                                                           "XMLROOT");
                        else if (i == 1)
                              newe = coerce_to_specific_type(pstate, newe, TEXTOID,
                                                                           "XMLROOT");
                        else
                              newe = coerce_to_specific_type(pstate, newe, INT4OID,
                                                                           "XMLROOT");
                        break;
                  case IS_XMLSERIALIZE:
                        /* not handled here */
                        Assert(false);
                        break;
                  case IS_DOCUMENT:
                        newe = coerce_to_specific_type(pstate, newe, XMLOID,
                                                                     "IS DOCUMENT");
                        break;
            }
            newx->args = lappend(newx->args, newe);
            i++;
      }

      return (Node *) newx;
}

static Node *
transformXmlSerialize(ParseState *pstate, XmlSerialize *xs)
{
      Node     *result;
      XmlExpr    *xexpr;
      Oid               targetType;
      int32       targetTypmod;

      xexpr = makeNode(XmlExpr);
      xexpr->op = IS_XMLSERIALIZE;
      xexpr->args = list_make1(coerce_to_specific_type(pstate,
                                                                   transformExpr(pstate, xs->expr),
                                                                               XMLOID,
                                                                               "XMLSERIALIZE"));

      targetType = typenameTypeId(pstate, xs->typename, &targetTypmod);

      xexpr->xmloption = xs->xmloption;
      xexpr->location = xs->location;
      /* We actually only need these to be able to parse back the expression. */
      xexpr->type = targetType;
      xexpr->typmod = targetTypmod;

      /*
       * The actual target type is determined this way.  SQL allows char and
       * varchar as target types.  We allow anything that can be cast implicitly
       * from text.  This way, user-defined text-like data types automatically
       * fit in.
       */
      result = coerce_to_target_type(pstate, (Node *) xexpr,
                                                   TEXTOID, targetType, targetTypmod,
                                                   COERCION_IMPLICIT,
                                                   COERCE_IMPLICIT_CAST,
                                                   -1);
      if (result == NULL)
            ereport(ERROR,
                        (errcode(ERRCODE_CANNOT_COERCE),
                         errmsg("cannot cast XMLSERIALIZE result to %s",
                                    format_type_be(targetType)),
                         parser_errposition(pstate, xexpr->location)));
      return result;
}

static Node *
transformBooleanTest(ParseState *pstate, BooleanTest *b)
{
      const char *clausename;

      switch (b->booltesttype)
      {
            case IS_TRUE:
                  clausename = "IS TRUE";
                  break;
            case IS_NOT_TRUE:
                  clausename = "IS NOT TRUE";
                  break;
            case IS_FALSE:
                  clausename = "IS FALSE";
                  break;
            case IS_NOT_FALSE:
                  clausename = "IS NOT FALSE";
                  break;
            case IS_UNKNOWN:
                  clausename = "IS UNKNOWN";
                  break;
            case IS_NOT_UNKNOWN:
                  clausename = "IS NOT UNKNOWN";
                  break;
            default:
                  elog(ERROR, "unrecognized booltesttype: %d",
                         (int) b->booltesttype);
                  clausename = NULL;      /* keep compiler quiet */
      }

      b->arg = (Expr *) transformExpr(pstate, (Node *) b->arg);

      b->arg = (Expr *) coerce_to_boolean(pstate,
                                                            (Node *) b->arg,
                                                            clausename);

      return (Node *) b;
}

static Node *
transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
{
      int               sublevels_up;

      /* CURRENT OF can only appear at top level of UPDATE/DELETE */
      Assert(pstate->p_target_rangetblentry != NULL);
      cexpr->cvarno = RTERangeTablePosn(pstate,
                                                        pstate->p_target_rangetblentry,
                                                        &sublevels_up);
      Assert(sublevels_up == 0);

      /* If a parameter is used, it must be of type REFCURSOR */
      if (cexpr->cursor_name == NULL)
      {
            Oid            *pptype = find_param_type(pstate, cexpr->cursor_param, -1);

            if (pstate->p_variableparams && *pptype == UNKNOWNOID)
            {
                  /* resolve unknown param type as REFCURSOR */
                  *pptype = REFCURSOROID;
            }
            else if (*pptype != REFCURSOROID)
            {
                  ereport(ERROR,
                              (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
                               errmsg("inconsistent types deduced for parameter $%d",
                                          cexpr->cursor_param),
                               errdetail("%s versus %s",
                                             format_type_be(*pptype),
                                             format_type_be(REFCURSOROID))));
            }
      }

      return (Node *) cexpr;
}

/*
 * Construct a whole-row reference to represent the notation "relation.*".
 *
 * A whole-row reference is a Var with varno set to the correct range
 * table entry, and varattno == 0 to signal that it references the whole
 * tuple.  (Use of zero here is unclean, since it could easily be confused
 * with error cases, but it's not worth changing now.)  The vartype indicates
 * a rowtype; either a named composite type, or RECORD.
 */
static Node *
transformWholeRowRef(ParseState *pstate, char *schemaname, char *relname,
                               int location)
{
      Var            *result;
      RangeTblEntry *rte;
      int               vnum;
      int               sublevels_up;
      Oid               toid;

      /* Look up the referenced RTE, creating it if needed */

      rte = refnameRangeTblEntry(pstate, schemaname, relname, location,
                                             &sublevels_up);

      if (rte == NULL)
            rte = addImplicitRTE(pstate,
                                           makeRangeVar(schemaname, relname, location));

      vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);

      /* Build the appropriate referencing node */

      switch (rte->rtekind)
      {
            case RTE_RELATION:
                  /* relation: the rowtype is a named composite type */
                  toid = get_rel_type_id(rte->relid);
                  if (!OidIsValid(toid))
                        elog(ERROR, "could not find type OID for relation %u",
                               rte->relid);
                  result = makeVar(vnum,
                                           InvalidAttrNumber,
                                           toid,
                                           -1,
                                           sublevels_up);
                  break;
            case RTE_FUNCTION:
                  toid = exprType(rte->funcexpr);
                  if (type_is_rowtype(toid))
                  {
                        /* func returns composite; same as relation case */
                        result = makeVar(vnum,
                                                 InvalidAttrNumber,
                                                 toid,
                                                 -1,
                                                 sublevels_up);
                  }
                  else
                  {
                        /*
                         * func returns scalar; instead of making a whole-row Var,
                         * just reference the function's scalar output.  (XXX this
                         * seems a tad inconsistent, especially if "f.*" was
                         * explicitly written ...)
                         */
                        result = makeVar(vnum,
                                                 1,
                                                 toid,
                                                 -1,
                                                 sublevels_up);
                  }
                  break;
            case RTE_VALUES:
                  toid = RECORDOID;
                  /* returns composite; same as relation case */
                  result = makeVar(vnum,
                                           InvalidAttrNumber,
                                           toid,
                                           -1,
                                           sublevels_up);
                  break;
            default:

                  /*
                   * RTE is a join or subselect.      We represent this as a whole-row
                   * Var of RECORD type.  (Note that in most cases the Var will be
                   * expanded to a RowExpr during planning, but that is not our
                   * concern here.)
                   */
                  result = makeVar(vnum,
                                           InvalidAttrNumber,
                                           RECORDOID,
                                           -1,
                                           sublevels_up);
                  break;
      }

      /* location is not filled in by makeVar */
      result->location = location;

      /* mark relation as requiring whole-row SELECT access */
      markVarForSelectPriv(pstate, result, rte);

      return (Node *) result;
}

/*
 * Handle an explicit CAST construct.
 *
 * Transform the argument, then look up the type name and apply any necessary
 * coercion function(s).
 */
static Node *
transformTypeCast(ParseState *pstate, TypeCast *tc)
{
      Node     *result;
      Node     *expr = transformExpr(pstate, tc->arg);
      Oid               inputType = exprType(expr);
      Oid               targetType;
      int32       targetTypmod;
      int               location;

      targetType = typenameTypeId(pstate, tc->typename, &targetTypmod);

      if (inputType == InvalidOid)
            return expr;                  /* do nothing if NULL input */

      /*
       * Location of the coercion is preferentially the location of the :: or
       * CAST symbol, but if there is none then use the location of the type
       * name (this can happen in TypeName 'string' syntax, for instance).
       */
      location = tc->location;
      if (location < 0)
            location = tc->typename->location;

      result = coerce_to_target_type(pstate, expr, inputType,
                                                   targetType, targetTypmod,
                                                   COERCION_EXPLICIT,
                                                   COERCE_EXPLICIT_CAST,
                                                   location);
      if (result == NULL)
            ereport(ERROR,
                        (errcode(ERRCODE_CANNOT_COERCE),
                         errmsg("cannot cast type %s to %s",
                                    format_type_be(inputType),
                                    format_type_be(targetType)),
                         parser_coercion_errposition(pstate, location, expr)));

      return result;
}

/*
 * Transform a "row compare-op row" construct
 *
 * The inputs are lists of already-transformed expressions.
 * As with coerce_type, pstate may be NULL if no special unknown-Param
 * processing is wanted.
 *
 * The output may be a single OpExpr, an AND or OR combination of OpExprs,
 * or a RowCompareExpr.  In all cases it is guaranteed to return boolean.
 * The AND, OR, and RowCompareExpr cases further imply things about the
 * behavior of the operators (ie, they behave as =, <>, or < <= > >=).
 */
static Node *
make_row_comparison_op(ParseState *pstate, List *opname,
                                 List *largs, List *rargs, int location)
{
      RowCompareExpr *rcexpr;
      RowCompareType rctype;
      List     *opexprs;
      List     *opnos;
      List     *opfamilies;
      ListCell   *l,
                     *r;
      List    **opfamily_lists;
      List    **opstrat_lists;
      Bitmapset  *strats;
      int               nopers;
      int               i;

      nopers = list_length(largs);
      if (nopers != list_length(rargs))
            ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("unequal number of entries in row expressions"),
                         parser_errposition(pstate, location)));

      /*
       * We can't compare zero-length rows because there is no principled basis
       * for figuring out what the operator is.
       */
      if (nopers == 0)
            ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot compare rows of zero length"),
                         parser_errposition(pstate, location)));

      /*
       * Identify all the pairwise operators, using make_op so that behavior is
       * the same as in the simple scalar case.
       */
      opexprs = NIL;
      forboth(l, largs, r, rargs)
      {
            Node     *larg = (Node *) lfirst(l);
            Node     *rarg = (Node *) lfirst(r);
            OpExpr         *cmp;

            cmp = (OpExpr *) make_op(pstate, opname, larg, rarg, location);
            Assert(IsA(cmp, OpExpr));

            /*
             * We don't use coerce_to_boolean here because we insist on the
             * operator yielding boolean directly, not via coercion.  If it
             * doesn't yield bool it won't be in any index opfamilies...
             */
            if (cmp->opresulttype != BOOLOID)
                  ereport(ERROR,
                              (errcode(ERRCODE_DATATYPE_MISMATCH),
                           errmsg("row comparison operator must yield type boolean, "
                                      "not type %s",
                                      format_type_be(cmp->opresulttype)),
                               parser_errposition(pstate, location)));
            if (expression_returns_set((Node *) cmp))
                  ereport(ERROR,
                              (errcode(ERRCODE_DATATYPE_MISMATCH),
                               errmsg("row comparison operator must not return a set"),
                               parser_errposition(pstate, location)));
            opexprs = lappend(opexprs, cmp);
      }

      /*
       * If rows are length 1, just return the single operator.  In this case we
       * don't insist on identifying btree semantics for the operator (but we
       * still require it to return boolean).
       */
      if (nopers == 1)
            return (Node *) linitial(opexprs);

      /*
       * Now we must determine which row comparison semantics (= <> < <= > >=)
       * apply to this set of operators.  We look for btree opfamilies
       * containing the operators, and see which interpretations (strategy
       * numbers) exist for each operator.
       */
      opfamily_lists = (List **) palloc(nopers * sizeof(List *));
      opstrat_lists = (List **) palloc(nopers * sizeof(List *));
      strats = NULL;
      i = 0;
      foreach(l, opexprs)
      {
            Oid               opno = ((OpExpr *) lfirst(l))->opno;
            Bitmapset  *this_strats;
            ListCell   *j;

            get_op_btree_interpretation(opno,
                                                      &opfamily_lists[i], &opstrat_lists[i]);

            /*
             * convert strategy number list to a Bitmapset to make the
             * intersection calculation easy.
             */
            this_strats = NULL;
            foreach(j, opstrat_lists[i])
            {
                  this_strats = bms_add_member(this_strats, lfirst_int(j));
            }
            if (i == 0)
                  strats = this_strats;
            else
                  strats = bms_int_members(strats, this_strats);
            i++;
      }

      /*
       * If there are multiple common interpretations, we may use any one of
       * them ... this coding arbitrarily picks the lowest btree strategy
       * number.
       */
      i = bms_first_member(strats);
      if (i < 0)
      {
            /* No common interpretation, so fail */
            ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("could not determine interpretation of row comparison operator %s",
                                    strVal(llast(opname))),
                         errhint("Row comparison operators must be associated with btree operator families."),
                         parser_errposition(pstate, location)));
      }
      rctype = (RowCompareType) i;

      /*
       * For = and <> cases, we just combine the pairwise operators with AND or
       * OR respectively.
       *
       * Note: this is presently the only place where the parser generates
       * BoolExpr with more than two arguments.  Should be OK since the rest of
       * the system thinks BoolExpr is N-argument anyway.
       */
      if (rctype == ROWCOMPARE_EQ)
            return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
      if (rctype == ROWCOMPARE_NE)
            return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);

      /*
       * Otherwise we need to choose exactly which opfamily to associate with
       * each operator.
       */
      opfamilies = NIL;
      for (i = 0; i < nopers; i++)
      {
            Oid               opfamily = InvalidOid;

            forboth(l, opfamily_lists[i], r, opstrat_lists[i])
            {
                  int               opstrat = lfirst_int(r);

                  if (opstrat == rctype)
                  {
                        opfamily = lfirst_oid(l);
                        break;
                  }
            }
            if (OidIsValid(opfamily))
                  opfamilies = lappend_oid(opfamilies, opfamily);
            else  /* should not happen */
                  ereport(ERROR,
                              (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                               errmsg("could not determine interpretation of row comparison operator %s",
                                          strVal(llast(opname))),
                     errdetail("There are multiple equally-plausible candidates."),
                               parser_errposition(pstate, location)));
      }

      /*
       * Now deconstruct the OpExprs and create a RowCompareExpr.
       *
       * Note: can't just reuse the passed largs/rargs lists, because of
       * possibility that make_op inserted coercion operations.
       */
      opnos = NIL;
      largs = NIL;
      rargs = NIL;
      foreach(l, opexprs)
      {
            OpExpr         *cmp = (OpExpr *) lfirst(l);

            opnos = lappend_oid(opnos, cmp->opno);
            largs = lappend(largs, linitial(cmp->args));
            rargs = lappend(rargs, lsecond(cmp->args));
      }

      rcexpr = makeNode(RowCompareExpr);
      rcexpr->rctype = rctype;
      rcexpr->opnos = opnos;
      rcexpr->opfamilies = opfamilies;
      rcexpr->largs = largs;
      rcexpr->rargs = rargs;

      return (Node *) rcexpr;
}

/*
 * Transform a "row IS DISTINCT FROM row" construct
 *
 * The input RowExprs are already transformed
 */
static Node *
make_row_distinct_op(ParseState *pstate, List *opname,
                               RowExpr *lrow, RowExpr *rrow,
                               int location)
{
      Node     *result = NULL;
      List     *largs = lrow->args;
      List     *rargs = rrow->args;
      ListCell   *l,
                     *r;

      if (list_length(largs) != list_length(rargs))
            ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("unequal number of entries in row expressions"),
                         parser_errposition(pstate, location)));

      forboth(l, largs, r, rargs)
      {
            Node     *larg = (Node *) lfirst(l);
            Node     *rarg = (Node *) lfirst(r);
            Node     *cmp;

            cmp = (Node *) make_distinct_op(pstate, opname, larg, rarg, location);
            if (result == NULL)
                  result = cmp;
            else
                  result = (Node *) makeBoolExpr(OR_EXPR,
                                                               list_make2(result, cmp),
                                                               location);
      }

      if (result == NULL)
      {
            /* zero-length rows?  Generate constant FALSE */
            result = makeBoolConst(false, false);
      }

      return result;
}

/*
 * make the node for an IS DISTINCT FROM operator
 */
static Expr *
make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree,
                         int location)
{
      Expr     *result;

      result = make_op(pstate, opname, ltree, rtree, location);
      if (((OpExpr *) result)->opresulttype != BOOLOID)
            ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                   errmsg("IS DISTINCT FROM requires = operator to yield boolean"),
                         parser_errposition(pstate, location)));

      /*
       * We rely on DistinctExpr and OpExpr being same struct
       */
      NodeSetTag(result, T_DistinctExpr);

      return result;
}

Generated by  Doxygen 1.6.0   Back to index