Avoid some zero-divide hazards in the planner.

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 < 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
index ce1fa4a9917900fdf2ce63e0680a31e45b4d1927..0c3570f265383a6cf2cbd6a0e27f03d69a017b67 100644 (file)
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -509,6 +509,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
index 16d3af32ed0fe3df233438bb80cd47bae1f1f00a..6647640b385d5c23978c03228b38e0562e81d684 100644 (file)
--- a/src/backend/optimizer/plan/planmain.c
+++ b/src/backend/optimizer/plan/planmain.c
@@ -356,7 +356,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
index 0bb8d20d8e6eea0a20ecc217946bd9bbed89c0c5..300fbcec1635bbdb2b47a055eef943e0c89c73c1 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -1295,11 +1295,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
index cc93fd5a44e4d3ef621cf831368a8ceeafcea9be..d18f8bf5155413796694be61e00bc19c27289b82 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -4622,8 +4622,8 @@ examine_simple_variable(PlannerInfo *root, Var *var,
  * *isdefault: set to TRUE if the result is a default rather than based on
  * anything meaningful.
  *
- * 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, bool *isdefault)
@@ -4699,7 +4699,7 @@ get_variable_numdistinct(VariableStatData *vardata, bool *isdefault)
     * 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.
@@ -4720,7 +4720,7 @@ get_variable_numdistinct(VariableStatData *vardata, bool *isdefault)
     * 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
@@ -4728,7 +4728,7 @@ get_variable_numdistinct(VariableStatData *vardata, bool *isdefault)
     * that the behavior isn't discontinuous.
     */
    if (ntuples < DEFAULT_NUM_DISTINCT)
-       return ntuples;
+       return clamp_row_est(ntuples);
 
    *isdefault = true;
    return DEFAULT_NUM_DISTINCT;