Teach eval_const_expressions() to simplify an ArrayCoerceExpr to a constant

when its input is constant and the element coercion function is immutable
(or nonexistent, ie, binary-coercible case).  This is an oversight in the
8.3 implementation of ArrayCoerceExpr, and its result is that certain cases
involving IN or NOT IN with constants don't get optimized as they should be.
Per experimentation with an example from Ow Mun Heng.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 11b6613426e85bd0418bb33382a8c8de6a538f15..7094ed0c87c0b040c87ce8adb47807e4a73e521b 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.254.2.2 2008/05/15 17:37:57 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.254.2.3 2008/08/26 02:16:39 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -2160,6 +2160,41 @@ eval_const_expressions_mutator(Node *node,
                newexpr->coerceformat = expr->coerceformat;
                return (Node *) newexpr;
        }
+       if (IsA(node, ArrayCoerceExpr))
+       {
+               ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;
+               Expr       *arg;
+               ArrayCoerceExpr *newexpr;
+
+               /*
+                * Reduce constants in the ArrayCoerceExpr's argument, then build
+                * a new ArrayCoerceExpr.
+                */
+               arg = (Expr *) eval_const_expressions_mutator((Node *) expr->arg,
+                                                                                                         context);
+
+               newexpr = makeNode(ArrayCoerceExpr);
+               newexpr->arg = arg;
+               newexpr->elemfuncid = expr->elemfuncid;
+               newexpr->resulttype = expr->resulttype;
+               newexpr->resulttypmod = expr->resulttypmod;
+               newexpr->isExplicit = expr->isExplicit;
+               newexpr->coerceformat = expr->coerceformat;
+
+               /*
+                * If constant argument and it's a binary-coercible or immutable
+                * conversion, we can simplify it to a constant.
+                */
+               if (arg && IsA(arg, Const) &&
+                       (!OidIsValid(newexpr->elemfuncid) ||
+                        func_volatile(newexpr->elemfuncid) == PROVOLATILE_IMMUTABLE))
+                       return (Node *) evaluate_expr((Expr *) newexpr,
+                                                                                 newexpr->resulttype,
+                                                                                 newexpr->resulttypmod);
+
+               /* Else we must return the partially-simplified node */
+               return (Node *) newexpr;
+       }
        if (IsA(node, CaseExpr))
        {
                /*----------