Fix an old error in clause_selectivity: the default selectivity estimate

tglsfdc · tglsfdc · commit df62977d0080 · 2008-01-11T17:00:45.000Z
for unhandled clause types ought to be 0.5, not 1.0.  I fear I introduced
this silliness due to misreading the intent of the very-poorly-structured
code that was there when we inherited the file from Berkeley.  The lack
of sanity in this behavior was exposed by an example from Sim Zacks.
(Arguably this is a bug fix and should be back-patched, but I'm a bit
hesitant to introduce a possible planner behavior change in the back
branches; it might detune queries that worked acceptably in the past.)

While at it, make estimation for DistinctExpr do something marginally
realistic, rather than just defaulting.
diff --git a/src/backend/optimizer/path/clausesel.c b/src/backend/optimizer/path/clausesel.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.89 2008/01/01 19:45:50 momjian Exp $
+ *	  $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.90 2008/01/11 17:00:45 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -428,7 +428,7 @@ clause_selectivity(PlannerInfo *root,
 				   int varRelid,
 				   JoinType jointype)
 {
-	Selectivity s1 = 1.0;		/* default for any unhandled clause type */
+	Selectivity s1 = 0.5;		/* default for any unhandled clause type */
 	RestrictInfo *rinfo = NULL;
 	bool		cacheable = false;
 
@@ -450,7 +450,7 @@ clause_selectivity(PlannerInfo *root,
 		if (rinfo->pseudoconstant)
 		{
 			if (!IsA(rinfo->clause, Const))
-				return s1;
+				return (Selectivity) 1.0;
 		}
 
 		/*
@@ -517,9 +517,8 @@ clause_selectivity(PlannerInfo *root,
 			{
 				/*
 				 * XXX not smart about subquery references... any way to do
-				 * better?
+				 * better than default?
 				 */
-				s1 = 0.5;
 			}
 			else
 			{
@@ -560,8 +559,7 @@ clause_selectivity(PlannerInfo *root,
 		}
 		else
 		{
-			/* XXX any way to do better? */
-			s1 = (Selectivity) 0.5;
+			/* XXX any way to do better than default? */
 		}
 	}
 	else if (not_clause(clause))
@@ -601,7 +599,7 @@ clause_selectivity(PlannerInfo *root,
 			s1 = s1 + s2 - s1 * s2;
 		}
 	}
-	else if (is_opclause(clause))
+	else if (is_opclause(clause) || IsA(clause, DistinctExpr))
 	{
 		Oid			opno = ((OpExpr *) clause)->opno;
 		bool		is_join_clause;
@@ -642,6 +640,15 @@ clause_selectivity(PlannerInfo *root,
 										 ((OpExpr *) clause)->args,
 										 varRelid);
 		}
+
+		/*
+		 * DistinctExpr has the same representation as OpExpr, but the
+		 * contained operator is "=" not "<>", so we must negate the result.
+		 * This estimation method doesn't give the right behavior for nulls,
+		 * but it's better than doing nothing.
+		 */
+		if (IsA(clause, DistinctExpr))
+			s1 = 1.0 - s1;
 	}
 	else if (is_funcclause(clause))
 	{
@@ -652,18 +659,15 @@ clause_selectivity(PlannerInfo *root,
 		 */
 		s1 = (Selectivity) 0.3333333;
 	}
+#ifdef NOT_USED
 	else if (is_subplan(clause))
 	{
 		/*
 		 * Just for the moment! FIX ME! - vadim 02/04/98
 		 */
 		s1 = (Selectivity) 0.5;
 	}
-	else if (IsA(clause, DistinctExpr))
-	{
-		/* can we do better? */
-		s1 = (Selectivity) 0.5;
-	}
+#endif
 	else if (IsA(clause, ScalarArrayOpExpr))
 	{
 		/* First, decide if it's a join clause, same as for OpExpr */

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`	`*`
`9`	`9`	`*`
`10`	`10`	`* IDENTIFICATION`
`11`		`- * $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.89 2008/01/01 19:45:50 momjian Exp $`
	`11`	`+ * $PostgreSQL: pgsql/src/backend/optimizer/path/clausesel.c,v 1.90 2008/01/11 17:00:45 tgl Exp $`
`12`	`12`	`*`
`13`	`13`	`*-------------------------------------------------------------------------`
`14`	`14`	`*/`
`@@ -428,7 +428,7 @@ clause_selectivity(PlannerInfo *root,`
`428`	`428`	`int varRelid,`
`429`	`429`	`JoinType jointype)`
`430`	`430`	`{`
`431`		`- Selectivity s1 = 1.0; /* default for any unhandled clause type */`
	`431`	`+ Selectivity s1 = 0.5; /* default for any unhandled clause type */`
`432`	`432`	`RestrictInfo *rinfo = NULL;`
`433`	`433`	`bool cacheable = false;`
`434`	`434`
`@@ -450,7 +450,7 @@ clause_selectivity(PlannerInfo *root,`
`450`	`450`	`if (rinfo->pseudoconstant)`
`451`	`451`	`{`
`452`	`452`	`if (!IsA(rinfo->clause, Const))`
`453`		`- return s1;`
	`453`	`+ return (Selectivity) 1.0;`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`/*`
`@@ -517,9 +517,8 @@ clause_selectivity(PlannerInfo *root,`
`517`	`517`	`{`
`518`	`518`	`/*`
`519`	`519`	`* XXX not smart about subquery references... any way to do`
`520`		`- * better?`
	`520`	`+ * better than default?`
`521`	`521`	`*/`
`522`		`- s1 = 0.5;`
`523`	`522`	`}`
`524`	`523`	`else`
`525`	`524`	`{`
`@@ -560,8 +559,7 @@ clause_selectivity(PlannerInfo *root,`
`560`	`559`	`}`
`561`	`560`	`else`
`562`	`561`	`{`
`563`		`- /* XXX any way to do better? */`
`564`		`- s1 = (Selectivity) 0.5;`
	`562`	`+ /* XXX any way to do better than default? */`
`565`	`563`	`}`
`566`	`564`	`}`
`567`	`565`	`else if (not_clause(clause))`
`@@ -601,7 +599,7 @@ clause_selectivity(PlannerInfo *root,`
`601`	`599`	`s1 = s1 + s2 - s1 * s2;`
`602`	`600`	`}`
`603`	`601`	`}`
`604`		`- else if (is_opclause(clause))`
	`602`	`+ else if (is_opclause(clause) \|\| IsA(clause, DistinctExpr))`
`605`	`603`	`{`
`606`	`604`	`Oid opno = ((OpExpr *) clause)->opno;`
`607`	`605`	`bool is_join_clause;`
`@@ -642,6 +640,15 @@ clause_selectivity(PlannerInfo *root,`
`642`	`640`	`((OpExpr *) clause)->args,`
`643`	`641`	`varRelid);`
`644`	`642`	`}`
	`643`	`+`
	`644`	`+ /*`
	`645`	`+ * DistinctExpr has the same representation as OpExpr, but the`
	`646`	`+ * contained operator is "=" not "<>", so we must negate the result.`
	`647`	`+ * This estimation method doesn't give the right behavior for nulls,`
	`648`	`+ * but it's better than doing nothing.`
	`649`	`+ */`
	`650`	`+ if (IsA(clause, DistinctExpr))`
	`651`	`+ s1 = 1.0 - s1;`
`645`	`652`	`}`
`646`	`653`	`else if (is_funcclause(clause))`
`647`	`654`	`{`
`@@ -652,18 +659,15 @@ clause_selectivity(PlannerInfo *root,`
`652`	`659`	`*/`
`653`	`660`	`s1 = (Selectivity) 0.3333333;`
`654`	`661`	`}`
	`662`	`+#ifdef NOT_USED`
`655`	`663`	`else if (is_subplan(clause))`
`656`	`664`	`{`
`657`	`665`	`/*`
`658`	`666`	`* Just for the moment! FIX ME! - vadim 02/04/98`
`659`	`667`	`*/`
`660`	`668`	`s1 = (Selectivity) 0.5;`
`661`	`669`	`}`
`662`		`- else if (IsA(clause, DistinctExpr))`
`663`		`- {`
`664`		`- /* can we do better? */`
`665`		`- s1 = (Selectivity) 0.5;`
`666`		`- }`
	`670`	`+#endif`
`667`	`671`	`else if (IsA(clause, ScalarArrayOpExpr))`
`668`	`672`	`{`
`669`	`673`	`/* First, decide if it's a join clause, same as for OpExpr */`