Fix performance bug in constant-expression simplifier. After finding

that the inputs to a given operator can be recursively simplified to
constants, it was evaluating the operator using the op's *original*
(unsimplified) arg list, so that any subexpressions had to be evaluated
again.  A constant subexpression at depth N got evaluated N times.
Probably not very important in practical situations, but it made us look
real slow in MySQL's 'crashme' test...

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 4bb84f1521463375055c07da42b45ec52e4fe20b..3ec5118ff77acf500367137febeb887f2cdb6379 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.60 2000/02/20 21:32:06 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.61 2000/03/12 19:32:06 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -991,18 +991,26 @@ eval_const_expressions_mutator (Node *node, void *context)
                                 * duplication of code and ensure we get the same result
                                 * as the executor would get.
                                 *
-                                * The only setup needed here is the replace_opid()
-                                * that we already did for the OP_EXPR case.
-                                *
+                                * Build a new Expr node containing the already-simplified
+                                * arguments.  The only other setup needed here is the
+                                * replace_opid() that we already did for the OP_EXPR case.
+                                */
+                               newexpr = makeNode(Expr);
+                               newexpr->typeOid = expr->typeOid;
+                               newexpr->opType = expr->opType;
+                               newexpr->oper = expr->oper;
+                               newexpr->args = args;
+                               /*
                                 * It is OK to pass econtext = NULL because none of the
                                 * ExecEvalExpr() code used in this situation will use
                                 * econtext.  That might seem fortuitous, but it's not
                                 * so unreasonable --- a constant expression does not
                                 * depend on context, by definition, n'est ce pas?
                                 */
-                               const_val = ExecEvalExpr((Node *) expr, NULL,
+                               const_val = ExecEvalExpr((Node *) newexpr, NULL,
                                                                                 &const_is_null, &isDone);
                                Assert(isDone); /* if this isn't set, we blew it... */
+                               pfree(newexpr);
                                /*
                                 * Make the constant result node.
                                 */