Add code to eval_const_expressions() to support const-simplification of

CoerceViaIO nodes.  This improves the ability of the planner to deal with
cases where the node input is a constant.  Per bug #4170.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 86654185392111db718e77d5694ea5e6a2311472..ea924222792c16a9e3d70aa78339bfb9cf4db25e 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.258 2008/05/12 00:00:49 alvherre Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.259 2008/05/15 17:37:49 tgl Exp $
  *
  * HISTORY
  *   AUTHOR            DATE            MAJOR EVENT
@@ -2106,6 +2106,71 @@ eval_const_expressions_mutator(Node *node,
            return (Node *) newrelabel;
        }
    }
+   if (IsA(node, CoerceViaIO))
+   {
+       CoerceViaIO *expr = (CoerceViaIO *) node;
+       Expr       *arg;
+       Oid         outfunc;
+       bool        outtypisvarlena;
+       Oid         infunc;
+       Oid         intypioparam;
+       Expr       *simple;
+       CoerceViaIO *newexpr;
+
+       /*
+        * Reduce constants in the CoerceViaIO's argument.
+        */
+       arg = (Expr *) eval_const_expressions_mutator((Node *) expr->arg,
+                                                     context);
+
+       /*
+        * CoerceViaIO represents calling the source type's output function
+        * then the result type's input function.  So, try to simplify it
+        * as though it were a stack of two such function calls.  First we
+        * need to know what the functions are.
+        */
+       getTypeOutputInfo(exprType((Node *) arg), &outfunc, &outtypisvarlena);
+       getTypeInputInfo(expr->resulttype, &infunc, &intypioparam);
+
+       simple = simplify_function(outfunc,
+                                  CSTRINGOID, -1,
+                                  list_make1(arg),
+                                  true, context);
+       if (simple)             /* successfully simplified output fn */
+       {
+           /*
+            * Input functions may want 1 to 3 arguments.  We always supply
+            * all three, trusting that nothing downstream will complain.
+            */
+           List       *args;
+
+           args = list_make3(simple,
+                             makeConst(OIDOID, -1, sizeof(Oid),
+                                       ObjectIdGetDatum(intypioparam),
+                                       false, true),
+                             makeConst(INT4OID, -1, sizeof(int32),
+                                       Int32GetDatum(-1),
+                                       false, true));
+
+           simple = simplify_function(infunc,
+                                      expr->resulttype, -1,
+                                      args,
+                                      true, context);
+           if (simple)         /* successfully simplified input fn */
+               return (Node *) simple;
+       }
+
+       /*
+        * The expression cannot be simplified any further, so build and
+        * return a replacement CoerceViaIO node using the possibly-simplified
+        * argument.
+        */
+       newexpr = makeNode(CoerceViaIO);
+       newexpr->arg = arg;
+       newexpr->resulttype = expr->resulttype;
+       newexpr->coerceformat = expr->coerceformat;
+       return (Node *) newexpr;
+   }
    if (IsA(node, CaseExpr))
    {
        /*----------