Teach estimate_array_length() to use statistics where available.

If we have DECHIST statistics about the argument expression, use
the average number of distinct elements as the array length estimate.
(It'd be better to use the average total number of elements, but
that is not currently calculated by compute_array_stats(), and
it's unclear that it'd be worth extra effort to get.)

To do this, we have to change the signature of estimate_array_length
to pass the "root" pointer.  While at it, also change its result
type to "double".  That's probably not really necessary, but it
avoids any risk of overflow of the value extracted from DECHIST.
All existing callers are going to use the result in a "double"
calculation anyway.

Paul Jungwirth, reviewed by Jian He and myself

Discussion: https://postgr.es/m/CA+renyUnM2d+SmrxKpDuAdpiq6FOM=FByvi6aS6yi__qyf6j9A@mail.gmail.com

diff --git a/src/backend/optimizer/path/costsize.c b/src/backend/optimizer/path/costsize.c
index 7cfebc95d69060a221e62c35826164a9bcefb92c..8b76e985296c5f983db2e68c79ed74fc49ef7a1a 100644 (file)
--- a/src/backend/optimizer/path/costsize.c
+++ b/src/backend/optimizer/path/costsize.c
@@ -1256,7 +1256,7 @@ cost_tidscan(Path *path, PlannerInfo *root,
    QualCost    qpqual_cost;
    Cost        cpu_per_tuple;
    QualCost    tid_qual_cost;
-   int         ntuples;
+   double      ntuples;
    ListCell   *l;
    double      spc_random_page_cost;
 
@@ -1283,7 +1283,7 @@ cost_tidscan(Path *path, PlannerInfo *root,
            ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) qual;
            Node       *arraynode = (Node *) lsecond(saop->args);
 
-           ntuples += estimate_array_length(arraynode);
+           ntuples += estimate_array_length(root, arraynode);
        }
        else if (IsA(qual, CurrentOfExpr))
        {
@@ -4770,7 +4770,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
        Node       *arraynode = (Node *) lsecond(saop->args);
        QualCost    sacosts;
        QualCost    hcosts;
-       int         estarraylen = estimate_array_length(arraynode);
+       double      estarraylen = estimate_array_length(context->root, arraynode);
 
        set_sa_opfuncid(saop);
        sacosts.startup = sacosts.per_tuple = 0;
@@ -4808,7 +4808,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
             */
            context->total.startup += sacosts.startup;
            context->total.per_tuple += sacosts.per_tuple *
-               estimate_array_length(arraynode) * 0.5;
+               estimate_array_length(context->root, arraynode) * 0.5;
        }
    }
    else if (IsA(node, Aggref) ||
@@ -4859,7 +4859,7 @@ cost_qual_eval_walker(Node *node, cost_qual_eval_context *context)
        context->total.startup += perelemcost.startup;
        if (perelemcost.per_tuple > 0)
            context->total.per_tuple += perelemcost.per_tuple *
-               estimate_array_length((Node *) acoerce->arg);
+               estimate_array_length(context->root, (Node *) acoerce->arg);
    }
    else if (IsA(node, RowCompareExpr))
    {

diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
index 957d21a0a0d7c496851a748f25da11b2527168ab..f3fee54e37060981976007cd988de0969bf13e27 100644 (file)
--- a/src/backend/utils/adt/arrayfuncs.c
+++ b/src/backend/utils/adt/arrayfuncs.c
@@ -6340,7 +6340,7 @@ array_unnest_support(PG_FUNCTION_ARGS)
            /* We can use estimated argument values here */
            arg1 = estimate_expression_value(req->root, linitial(args));
 
-           req->rows = estimate_array_length(arg1);
+           req->rows = estimate_array_length(req->root, arg1);
            ret = (Node *) req;
        }
    }

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index 7a3f69f2d9ddf32a386c67cdd65d1f237c8d8096..dbcd98d9851665336ce80ad8bd6e45f551734784 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -2128,10 +2128,11 @@ scalararraysel(PlannerInfo *root,
 /*
  * Estimate number of elements in the array yielded by an expression.
  *
- * It's important that this agree with scalararraysel.
+ * Note: the result is integral, but we use "double" to avoid overflow
+ * concerns.  Most callers will use it in double-type expressions anyway.
  */
-int
-estimate_array_length(Node *arrayexpr)
+double
+estimate_array_length(PlannerInfo *root, Node *arrayexpr)
 {
    /* look through any binary-compatible relabeling of arrayexpr */
    arrayexpr = strip_array_coercion(arrayexpr);
@@ -2152,11 +2153,39 @@ estimate_array_length(Node *arrayexpr)
    {
        return list_length(((ArrayExpr *) arrayexpr)->elements);
    }
-   else
+   else if (arrayexpr)
    {
-       /* default guess --- see also scalararraysel */
-       return 10;
+       /* See if we can find any statistics about it */
+       VariableStatData vardata;
+       AttStatsSlot sslot;
+       double      nelem = 0;
+
+       examine_variable(root, arrayexpr, 0, &vardata);
+       if (HeapTupleIsValid(vardata.statsTuple))
+       {
+           /*
+            * Found stats, so use the average element count, which is stored
+            * in the last stanumbers element of the DECHIST statistics.
+            * Actually that is the average count of *distinct* elements;
+            * perhaps we should scale it up somewhat?
+            */
+           if (get_attstatsslot(&sslot, vardata.statsTuple,
+                                STATISTIC_KIND_DECHIST, InvalidOid,
+                                ATTSTATSSLOT_NUMBERS))
+           {
+               if (sslot.nnumbers > 0)
+                   nelem = clamp_row_est(sslot.numbers[sslot.nnumbers - 1]);
+               free_attstatsslot(&sslot);
+           }
+       }
+       ReleaseVariableStats(vardata);
+
+       if (nelem > 0)
+           return nelem;
    }
+
+   /* Else use a default guess --- this should match scalararraysel */
+   return 10;
 }
 
 /*
@@ -6540,7 +6569,7 @@ genericcostestimate(PlannerInfo *root,
        if (IsA(rinfo->clause, ScalarArrayOpExpr))
        {
            ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) rinfo->clause;
-           int         alength = estimate_array_length(lsecond(saop->args));
+           double      alength = estimate_array_length(root, lsecond(saop->args));
 
            if (alength > 1)
                num_sa_scans *= alength;
@@ -6820,7 +6849,7 @@ btcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
            {
                ScalarArrayOpExpr *saop = (ScalarArrayOpExpr *) clause;
                Node       *other_operand = (Node *) lsecond(saop->args);
-               int         alength = estimate_array_length(other_operand);
+               double      alength = estimate_array_length(root, other_operand);
 
                clause_op = saop->opno;
                found_saop = true;
@@ -7414,7 +7443,7 @@ gincost_scalararrayopexpr(PlannerInfo *root,
    {
        counts->exactEntries++;
        counts->searchEntries++;
-       counts->arrayScans *= estimate_array_length(rightop);
+       counts->arrayScans *= estimate_array_length(root, rightop);
        return true;
    }
 

diff --git a/src/include/utils/selfuncs.h b/src/include/utils/selfuncs.h
index 6dd5171d548c1967948f471662db3e1f61db9dbd..2fa4c4fc1b0d09f628af0bb3a9dd487fee0dbf15 100644 (file)
--- a/src/include/utils/selfuncs.h
+++ b/src/include/utils/selfuncs.h
@@ -200,7 +200,7 @@ extern Selectivity scalararraysel(PlannerInfo *root,
                                  ScalarArrayOpExpr *clause,
                                  bool is_join_clause,
                                  int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo);
-extern int estimate_array_length(Node *arrayexpr);
+extern double estimate_array_length(PlannerInfo *root, Node *arrayexpr);
 extern Selectivity rowcomparesel(PlannerInfo *root,
                                 RowCompareExpr *clause,
                                 int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo);