Allow planner to fold "stable" functions to constants when forming

selectivity estimates, per recent discussion.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 0f7d8dc31fcae1c2640cb4e2d91c5059bc36f17d..6bf9990ccf50bcc0094b0018f7ad0c02fc02b5b5 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.183 2004/10/22 17:20:05 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/optimizer/util/clauses.c,v 1.184 2004/11/09 21:42:53 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -76,7 +76,8 @@ static Expr *simplify_function(Oid funcid, Oid result_type, List *args,
                                  bool allow_inline,
                                  eval_const_expressions_context *context);
 static Expr *evaluate_function(Oid funcid, Oid result_type, List *args,
-                                 HeapTuple func_tuple);
+                                 HeapTuple func_tuple,
+                                 eval_const_expressions_context *context);
 static Expr *inline_function(Oid funcid, Oid result_type, List *args,
                                HeapTuple func_tuple,
                                eval_const_expressions_context *context);
@@ -1151,7 +1152,7 @@ eval_const_expressions(Node *node)
        return eval_const_expressions_mutator(node, &context);
 }
 
-/*
+/*--------------------
  * estimate_expression_value
  *
  * This function attempts to estimate the value of an expression for
@@ -1159,11 +1160,11 @@ eval_const_expressions(Node *node)
  * eval_const_expressions(): we will perform constant reductions that are
  * not necessarily 100% safe, but are reasonable for estimation purposes.
  *
- * Currently the only such transform is to substitute values for Params,
- * when a bound Param value has been made available by the caller of planner().
- * In future we might consider other things, such as reducing now() to current
- * time.  (XXX seems like there could be a lot of scope for ideas here...
- * but we might need more volatility classifications ...)
+ * Currently the extra steps that are taken in this mode are:
+ * 1. Substitute values for Params, where a bound Param value has been made
+ *    available by the caller of planner().
+ * 2. Fold stable, as well as immutable, functions to constants.
+ *--------------------
  */
 Node *
 estimate_expression_value(Node *node)
@@ -1909,7 +1910,8 @@ simplify_function(Oid funcid, Oid result_type, List *args,
        if (!HeapTupleIsValid(func_tuple))
                elog(ERROR, "cache lookup failed for function %u", funcid);
 
-       newexpr = evaluate_function(funcid, result_type, args, func_tuple);
+       newexpr = evaluate_function(funcid, result_type, args,
+                                                               func_tuple, context);
 
        if (!newexpr && allow_inline)
                newexpr = inline_function(funcid, result_type, args,
@@ -1925,14 +1927,16 @@ simplify_function(Oid funcid, Oid result_type, List *args,
  *
  * We can do this if the function is strict and has any constant-null inputs
  * (just return a null constant), or if the function is immutable and has all
- * constant inputs (call it and return the result as a Const node).
+ * constant inputs (call it and return the result as a Const node).  In
+ * estimation mode we are willing to pre-evaluate stable functions too.
  *
  * Returns a simplified expression if successful, or NULL if cannot
  * simplify the function.
  */
 static Expr *
 evaluate_function(Oid funcid, Oid result_type, List *args,
-                                 HeapTuple func_tuple)
+                                 HeapTuple func_tuple,
+                                 eval_const_expressions_context *context)
 {
        Form_pg_proc funcform = (Form_pg_proc) GETSTRUCT(func_tuple);
        bool            has_nonconst_input = false;
@@ -1967,12 +1971,25 @@ evaluate_function(Oid funcid, Oid result_type, List *args,
                return (Expr *) makeNullConst(result_type);
 
        /*
-        * Otherwise, can simplify only if the function is immutable and all
-        * inputs are constants. (For a non-strict function, constant NULL
-        * inputs are treated the same as constant non-NULL inputs.)
+        * Otherwise, can simplify only if all inputs are constants. (For a
+        * non-strict function, constant NULL inputs are treated the same as
+        * constant non-NULL inputs.)
         */
-       if (funcform->provolatile != PROVOLATILE_IMMUTABLE ||
-               has_nonconst_input)
+       if (has_nonconst_input)
+               return NULL;
+
+       /*
+        * Ordinarily we are only allowed to simplify immutable functions.
+        * But for purposes of estimation, we consider it okay to simplify
+        * functions that are merely stable; the risk that the result might
+        * change from planning time to execution time is worth taking in
+        * preference to not being able to estimate the value at all.
+        */
+       if (funcform->provolatile == PROVOLATILE_IMMUTABLE)
+               /* okay */ ;
+       else if (context->estimate && funcform->provolatile == PROVOLATILE_STABLE)
+               /* okay */ ;
+       else
                return NULL;
 
        /*