Fix transformExpr() to not scribble on its input datastructure while

transforming CASE expressions.  This was definitely confusing
FigureColname, and might lead to bad things elsewhere as well.

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index d1512c61c0e61b43fd81a62cb3e5fe825f9842eb..5db1ab867fdddce85678578e8c358c8636a7551d 100644 (file)
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.102 2001/09/28 08:09:09 thomas Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.103 2001/10/08 21:46:59 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -426,15 +426,23 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
                case T_CaseExpr:
                        {
                                CaseExpr   *c = (CaseExpr *) expr;
-                               CaseWhen   *w;
+                               CaseExpr   *newc = makeNode(CaseExpr);
+                               List       *newargs = NIL;
                                List       *typeids = NIL;
                                List       *args;
+                               Node       *defresult;
                                Oid                     ptype;
 
                                /* transform the list of arguments */
                                foreach(args, c->args)
                                {
-                                       w = lfirst(args);
+                                       CaseWhen   *w = (CaseWhen *) lfirst(args);
+                                       CaseWhen   *neww = makeNode(CaseWhen);
+                                       Node       *warg;
+
+                                       Assert(IsA(w, CaseWhen));
+
+                                       warg = w->expr;
                                        if (c->arg != NULL)
                                        {
                                                /* shorthand form was specified, so expand... */
@@ -443,31 +451,51 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
                                                a->oper = OP;
                                                a->opname = "=";
                                                a->lexpr = c->arg;
-                                               a->rexpr = w->expr;
-                                               w->expr = (Node *) a;
+                                               a->rexpr = warg;
+                                               warg = (Node *) a;
                                        }
-                                       lfirst(args) = transformExpr(pstate, (Node *) w, precedence);
-                                       typeids = lappendi(typeids, exprType(w->result));
+                                       neww->expr = transformExpr(pstate, warg, precedence);
+
+                                       if (! coerce_to_boolean(pstate, &neww->expr))
+                                               elog(ERROR, "WHEN clause must have a boolean result");
+
+                                       /*
+                                        * result is NULL for NULLIF() construct - thomas
+                                        * 1998-11-11
+                                        */
+                                       warg = w->result;
+                                       if (warg == NULL)
+                                       {
+                                               A_Const    *n = makeNode(A_Const);
+
+                                               n->val.type = T_Null;
+                                               warg = (Node *) n;
+                                       }
+                                       neww->result = transformExpr(pstate, warg, precedence);
+
+                                       newargs = lappend(newargs, neww);
+                                       typeids = lappendi(typeids, exprType(neww->result));
                                }
 
+                               newc->args = newargs;
+
                                /*
                                 * It's not shorthand anymore, so drop the implicit
-                                * argument. This is necessary to keep the executor from
-                                * seeing an untransformed expression... not to mention
-                                * keeping a re-application of transformExpr from doing
-                                * the wrong thing.
+                                * argument. This is necessary to keep any re-application
+                                * of transformExpr from doing the wrong thing.
                                 */
-                               c->arg = NULL;
+                               newc->arg = NULL;
 
                                /* transform the default clause */
-                               if (c->defresult == NULL)
+                               defresult = c->defresult;
+                               if (defresult == NULL)
                                {
                                        A_Const    *n = makeNode(A_Const);
 
                                        n->val.type = T_Null;
-                                       c->defresult = (Node *) n;
+                                       defresult = (Node *) n;
                                }
-                               c->defresult = transformExpr(pstate, c->defresult, precedence);
+                               newc->defresult = transformExpr(pstate, defresult, precedence);
 
                                /*
                                 * Note: default result is considered the most significant
@@ -475,49 +503,29 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
                                 * code worked before, but it seems a little bogus to me
                                 * --- tgl
                                 */
-                               typeids = lconsi(exprType(c->defresult), typeids);
+                               typeids = lconsi(exprType(newc->defresult), typeids);
 
                                ptype = select_common_type(typeids, "CASE");
-                               c->casetype = ptype;
+                               newc->casetype = ptype;
 
                                /* Convert default result clause, if necessary */
-                               c->defresult = coerce_to_common_type(pstate, c->defresult,
-                                                                                                        ptype, "CASE/ELSE");
+                               newc->defresult = coerce_to_common_type(pstate,
+                                                                                                               newc->defresult,
+                                                                                                               ptype,
+                                                                                                               "CASE/ELSE");
 
                                /* Convert when-clause results, if necessary */
-                               foreach(args, c->args)
-                               {
-                                       w = lfirst(args);
-                                       w->result = coerce_to_common_type(pstate, w->result,
-                                                                                                         ptype, "CASE/WHEN");
-                               }
-
-                               result = expr;
-                               break;
-                       }
-
-               case T_CaseWhen:
-                       {
-                               CaseWhen   *w = (CaseWhen *) expr;
-
-                               w->expr = transformExpr(pstate, w->expr, precedence);
-
-                               if (! coerce_to_boolean(pstate, &w->expr))
-                                       elog(ERROR, "WHEN clause must have a boolean result");
-
-                               /*
-                                * result is NULL for NULLIF() construct - thomas
-                                * 1998-11-11
-                                */
-                               if (w->result == NULL)
+                               foreach(args, newc->args)
                                {
-                                       A_Const    *n = makeNode(A_Const);
+                                       CaseWhen   *w = (CaseWhen *) lfirst(args);
 
-                                       n->val.type = T_Null;
-                                       w->result = (Node *) n;
+                                       w->result = coerce_to_common_type(pstate,
+                                                                                                         w->result,
+                                                                                                         ptype,
+                                                                                                         "CASE/WHEN");
                                }
-                               w->result = transformExpr(pstate, w->result, precedence);
-                               result = expr;
+
+                               result = (Node *) newc;
                                break;
                        }