Tighten inline_function's test for overly complex parameters. This

should catch most situations where repeated inlining blows up the
expression complexity unreasonably, as in Joe Conway's recent example.

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 6060f462e8f4c1219cc139a1947447f77817f482..3ebc1c650e87226807df288ba12fcf10671d6af0 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.148 2003/07/28 18:33:18 tgl Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.149 2003/08/03 23:46:37 tgl Exp $
  *
  * HISTORY
  *       AUTHOR                        DATE                    MAJOR EVENT
@@ -26,6 +26,7 @@
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "optimizer/clauses.h"
+#include "optimizer/cost.h"
 #include "optimizer/planmain.h"
 #include "optimizer/var.h"
 #include "parser/analyze.h"
@@ -1710,8 +1711,12 @@ evaluate_function(Oid funcid, Oid result_type, List *args,
  * so we keep track of which functions we are already expanding and
  * do not re-expand them.  Also, if a parameter is used more than once
  * in the SQL-function body, we require it not to contain any volatile
- * functions or sublinks --- volatiles might deliver inconsistent answers,
- * and subplans might be unreasonably expensive to evaluate multiple times.
+ * functions (volatiles might deliver inconsistent answers) nor to be
+ * unreasonably expensive to evaluate.  The expensiveness check not only
+ * prevents us from doing multiple evaluations of an expensive parameter
+ * at runtime, but is a safety value to limit growth of an expression due
+ * to repeated inlining.
+ *
  * We must also beware of changing the volatility or strictness status of
  * functions by inlining them.
  *
@@ -1912,9 +1917,26 @@ inline_function(Oid funcid, Oid result_type, List *args,
                }
                else if (usecounts[i] != 1)
                {
-                       /* Param used multiple times: uncool if volatile or expensive */
-                       if (contain_volatile_functions(param) ||
-                               contain_subplans(param))
+                       /* Param used multiple times: uncool if expensive or volatile */
+                       QualCost        eval_cost;
+
+                       /*
+                        * We define "expensive" as "contains any subplan or more than
+                        * 10 operators".  Note that the subplan search has to be done
+                        * explicitly, since cost_qual_eval() will barf on unplanned
+                        * subselects.
+                        */
+                       if (contain_subplans(param))
+                               goto fail;
+                       cost_qual_eval(&eval_cost, makeList1(param));
+                       if (eval_cost.startup + eval_cost.per_tuple >
+                               10 * cpu_operator_cost)
+                               goto fail;
+                       /*
+                        * Check volatility last since this is more expensive than the
+                        * above tests
+                        */
+                       if (contain_volatile_functions(param))
                                goto fail;
                }
                i++;