Avoid some zero-divide hazards in the planner.

tglsfdc · tglsfdc · commit 54833c5e772e · 2015-07-30T12:11:23.000-04:00
Although I think on all modern machines floating division by zero
results in Infinity not SIGFPE, we still don't want infinities
running around in the planner's costing estimates; too much risk
of that leading to insane behavior.

grouping_planner() failed to consider the possibility that final_rel
might be known dummy and hence have zero rowcount.  (I wonder if it
would be better to set a rows estimate of 1 for dummy relations?
But at least in the back branches, changing this convention seems
like a bad idea, so I'll leave that for another day.)

Make certain that get_variable_numdistinct() produces a nonzero result.
The case that can be shown to be broken is with stadistinct &lt; 0.0 and
small ntuples; we did not prevent the result from rounding to zero.
For good luck I applied clamp_row_est() to all the nonconstant return
values.

In ExecChooseHashTableSize(), Assert that we compute positive nbuckets
and nbatch.  I know of no reason to think this isn't the case, but it
seems like a good safety check.

Per reports from Piotr Stefaniak.  Back-patch to all active branches.
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
@@ -508,6 +508,9 @@ ExecChooseHashTableSize(double ntuples, int tupwidth, bool useskew,
 		i++;
 	nbuckets = (1 << i);
 
+	Assert(nbuckets > 0);
+	Assert(nbatch > 0);
+
 	*numbuckets = nbuckets;
 	*numbatches = nbatch;
 }
diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
@@ -364,7 +364,7 @@ query_planner(PlannerInfo *root, List *tlist,
 		 * can be divided by the number of tuples.
 		 */
 		if (tuple_fraction >= 1.0)
-			tuple_fraction /= final_rel->rows;
+			tuple_fraction /= clamp_row_est(final_rel->rows);
 	}
 
 	/*
diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
@@ -1116,11 +1116,14 @@ grouping_planner(PlannerInfo *root, double tuple_fraction)
 		/*
 		 * Extract rowcount and width estimates for possible use in grouping
 		 * decisions.  Beware here of the possibility that
-		 * cheapest_path->parent is NULL (ie, there is no FROM clause).
+		 * cheapest_path->parent is NULL (ie, there is no FROM clause).  Also,
+		 * if the final rel has been proven dummy, its rows estimate will be
+		 * zero; clamp it to one to avoid zero-divide in subsequent
+		 * calculations.
 		 */
 		if (cheapest_path->parent)
 		{
-			path_rows = cheapest_path->parent->rows;
+			path_rows = clamp_row_est(cheapest_path->parent->rows);
 			path_width = cheapest_path->parent->width;
 		}
 		else
diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
@@ -4337,8 +4337,8 @@ examine_variable(PlannerInfo *root, Node *node, int varRelid,
  *
  * vardata: results of examine_variable
  *
- * NB: be careful to produce an integral result, since callers may compare
- * the result to exact integer counts.
+ * NB: be careful to produce a positive integral result, since callers may
+ * compare the result to exact integer counts, or might divide by it.
  */
 double
 get_variable_numdistinct(VariableStatData *vardata)
@@ -4412,7 +4412,7 @@ get_variable_numdistinct(VariableStatData *vardata)
 	 * If we had an absolute estimate, use that.
 	 */
 	if (stadistinct > 0.0)
-		return stadistinct;
+		return clamp_row_est(stadistinct);
 
 	/*
 	 * Otherwise we need to get the relation size; punt if not available.
@@ -4427,14 +4427,14 @@ get_variable_numdistinct(VariableStatData *vardata)
 	 * If we had a relative estimate, use that.
 	 */
 	if (stadistinct < 0.0)
-		return floor((-stadistinct * ntuples) + 0.5);
+		return clamp_row_est(-stadistinct * ntuples);
 
 	/*
 	 * With no data, estimate ndistinct = ntuples if the table is small, else
 	 * use default.
 	 */
 	if (ntuples < DEFAULT_NUM_DISTINCT)
-		return ntuples;
+		return clamp_row_est(ntuples);
 
 	return DEFAULT_NUM_DISTINCT;
 }

Original file line number	Diff line number	Diff line change
`@@ -508,6 +508,9 @@ ExecChooseHashTableSize(double ntuples, int tupwidth, bool useskew,`
`508`	`508`	`i++;`
`509`	`509`	`nbuckets = (1 << i);`
`510`	`510`
	`511`	`+ Assert(nbuckets > 0);`
	`512`	`+ Assert(nbatch > 0);`
	`513`	`+`
`511`	`514`	`*numbuckets = nbuckets;`
`512`	`515`	`*numbatches = nbatch;`
`513`	`516`	`}`
Original file line number	Diff line number	Diff line change
`@@ -364,7 +364,7 @@ query_planner(PlannerInfo root, List tlist,`
`364`	`364`	`* can be divided by the number of tuples.`
`365`	`365`	`*/`
`366`	`366`	`if (tuple_fraction >= 1.0)`
`367`		`- tuple_fraction /= final_rel->rows;`
	`367`	`+ tuple_fraction /= clamp_row_est(final_rel->rows);`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`/*`