Tweak recognition of range-clause pairs so that 'var > $1 AND var < $2'

(ie, parameters instead of consts) will be treated as a range query.
We do not know the actual selectivities involved, but it seems like
a good idea to use a smaller estimate than we would use for two unrelated
inequalities.

diff --git a/src/backend/optimizer/path/clausesel.c b/src/backend/optimizer/path/clausesel.c
index 95b9ba4b90dd15ac3ea0a42fdd892b4cab6365d4..62a5b0295c35e366f35b01508d8ed550221aaebb 100644 (file)
--- a/src/backend/optimizer/path/clausesel.c
+++ b/src/backend/optimizer/path/clausesel.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.36 2000/05/30 00:49:46 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.37 2000/05/31 15:38:53 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -95,7 +95,7 @@ restrictlist_selectivity(Query *root,
  * directly as a 0..1 value but we need to convert losel to 1-losel before
  * interpreting it as a value. Then the available range is 1-losel to hisel.)
  * If the calculation yields zero or negative, however, we chicken out and
- * use the default interpretation; that probably means that one or both
+ * use a default estimate; that probably means that one or both
  * selectivities is a default estimate rather than an actual range value.
  * Of course this is all very dependent on the behavior of
  * scalarltsel/scalargtsel; perhaps some day we can generalize the approach.
@@ -120,10 +120,12 @@ clauselist_selectivity(Query *root,
        Selectivity s2;
 
        /*
-        * See if it looks like a restriction clause with a constant. (If
-        * it's not a constant we can't really trust the selectivity!) NB:
-        * for consistency of results, this fragment of code had better
-        * match what clause_selectivity() would do.
+        * See if it looks like a restriction clause with a Const or Param
+        * on one side.  (Anything more complicated than that might not
+        * behave in the simple way we are expecting.)
+        *
+        * NB: for consistency of results, this fragment of code had better
+        * match what clause_selectivity() would do in the cases it handles.
         */
        if (varRelid != 0 || NumRelids(clause) == 1)
        {
@@ -134,41 +136,48 @@ clauselist_selectivity(Query *root,
 
            get_relattval(clause, varRelid,
                          &relidx, &attno, &constval, &flag);
-           if (relidx != 0 && (flag & SEL_CONSTANT))
+           if (relidx != 0)
            {
                /* if get_relattval succeeded, it must be an opclause */
-               Oid         opno = ((Oper *) ((Expr *) clause)->oper)->opno;
-               RegProcedure oprrest = get_oprrest(opno);
+               Var        *other;
 
-               if (!oprrest)
-                   s2 = (Selectivity) 0.5;
-               else
-                   s2 = restriction_selectivity(oprrest, opno,
-                                                getrelid(relidx,
-                                                         root->rtable),
-                                                attno,
-                                                constval, flag);
-
-               /*
-                * If we reach here, we have computed the same result that
-                * clause_selectivity would, so we can just use s2 if it's
-                * the wrong oprrest.  But if it's the right oprrest, add
-                * the clause to rqlist for later processing.
-                */
-               switch (oprrest)
+               other = (flag & SEL_RIGHT) ? get_rightop((Expr *) clause) :
+                   get_leftop((Expr *) clause);
+               if (IsA(other, Const) || IsA(other, Param))
                {
-                   case F_SCALARLTSEL:
-                       addRangeClause(&rqlist, clause, flag, true, s2);
-                       break;
-                   case F_SCALARGTSEL:
-                       addRangeClause(&rqlist, clause, flag, false, s2);
-                       break;
-                   default:
-                       /* Just merge the selectivity in generically */
-                       s1 = s1 * s2;
-                       break;
+                   Oid     opno = ((Oper *) ((Expr *) clause)->oper)->opno;
+                   RegProcedure oprrest = get_oprrest(opno);
+
+                   if (!oprrest)
+                       s2 = (Selectivity) 0.5;
+                   else
+                       s2 = restriction_selectivity(oprrest, opno,
+                                                    getrelid(relidx,
+                                                             root->rtable),
+                                                    attno,
+                                                    constval, flag);
+
+                   /*
+                    * If we reach here, we have computed the same result that
+                    * clause_selectivity would, so we can just use s2 if it's
+                    * the wrong oprrest.  But if it's the right oprrest, add
+                    * the clause to rqlist for later processing.
+                    */
+                   switch (oprrest)
+                   {
+                       case F_SCALARLTSEL:
+                           addRangeClause(&rqlist, clause, flag, true, s2);
+                           break;
+                       case F_SCALARGTSEL:
+                           addRangeClause(&rqlist, clause, flag, false, s2);
+                           break;
+                       default:
+                           /* Just merge the selectivity in generically */
+                           s1 = s1 * s2;
+                           break;
+                   }
+                   continue;   /* drop to loop bottom */
                }
-               continue;       /* drop to loop bottom */
            }
        }
        /* Not the right form, so treat it generically. */
@@ -374,7 +383,7 @@ clause_selectivity(Query *root,
                                         BooleanEqualOperator,
                                         getrelid(varno, root->rtable),
                                         ((Var *) clause)->varattno,
-                                        Int8GetDatum(true),
+                                        BoolGetDatum(true),
                                         SEL_CONSTANT | SEL_RIGHT);
        /* an outer-relation bool var is taken as always true... */
    }