Refactor create_limit_path() to share cost adjustment code with FDWs.

This is in preparation for an upcoming commit.

Author: Etsuro Fujita
Reviewed-By: Antonin Houska and Jeff Janes
Discussion: https://postgr.es/m/87pnz1aby9.fsf@news-spur.riddles.org.uk

diff --git a/src/backend/optimizer/util/pathnode.c b/src/backend/optimizer/util/pathnode.c
index 56de8fc370aafb413ad8d29702aef7ac3d36574a..1ea89ff54c984d06444bc0858cf83bcc89059c2e 100644 (file)
--- a/src/backend/optimizer/util/pathnode.c
+++ b/src/backend/optimizer/util/pathnode.c
@@ -3578,17 +3578,42 @@ create_limit_path(PlannerInfo *root, RelOptInfo *rel,
 
        /*
         * Adjust the output rows count and costs according to the offset/limit.
-        * This is only a cosmetic issue if we are at top level, but if we are
-        * building a subquery then it's important to report correct info to the
-        * outer planner.
-        *
-        * When the offset or count couldn't be estimated, use 10% of the
-        * estimated number of rows emitted from the subpath.
-        *
-        * XXX we don't bother to add eval costs of the offset/limit expressions
-        * themselves to the path costs.  In theory we should, but in most cases
-        * those expressions are trivial and it's just not worth the trouble.
         */
+       adjust_limit_rows_costs(&pathnode->path.rows,
+                                                       &pathnode->path.startup_cost,
+                                                       &pathnode->path.total_cost,
+                                                       offset_est, count_est);
+
+       return pathnode;
+}
+
+/*
+ * adjust_limit_rows_costs
+ *       Adjust the size and cost estimates for a LimitPath node according to the
+ *       offset/limit.
+ *
+ * This is only a cosmetic issue if we are at top level, but if we are
+ * building a subquery then it's important to report correct info to the outer
+ * planner.
+ *
+ * When the offset or count couldn't be estimated, use 10% of the estimated
+ * number of rows emitted from the subpath.
+ *
+ * XXX we don't bother to add eval costs of the offset/limit expressions
+ * themselves to the path costs.  In theory we should, but in most cases those
+ * expressions are trivial and it's just not worth the trouble.
+ */
+void
+adjust_limit_rows_costs(double *rows,  /* in/out parameter */
+                                               Cost *startup_cost,     /* in/out parameter */
+                                               Cost *total_cost,       /* in/out parameter */
+                                               int64 offset_est,
+                                               int64 count_est)
+{
+       double          input_rows = *rows;
+       Cost            input_startup_cost = *startup_cost;
+       Cost            input_total_cost = *total_cost;
+
        if (offset_est != 0)
        {
                double          offset_rows;
@@ -3596,16 +3621,16 @@ create_limit_path(PlannerInfo *root, RelOptInfo *rel,
                if (offset_est > 0)
                        offset_rows = (double) offset_est;
                else
-                       offset_rows = clamp_row_est(subpath->rows * 0.10);
-               if (offset_rows > pathnode->path.rows)
-                       offset_rows = pathnode->path.rows;
-               if (subpath->rows > 0)
-                       pathnode->path.startup_cost +=
-                               (subpath->total_cost - subpath->startup_cost)
-                               * offset_rows / subpath->rows;
-               pathnode->path.rows -= offset_rows;
-               if (pathnode->path.rows < 1)
-                       pathnode->path.rows = 1;
+                       offset_rows = clamp_row_est(input_rows * 0.10);
+               if (offset_rows > *rows)
+                       offset_rows = *rows;
+               if (input_rows > 0)
+                       *startup_cost +=
+                               (input_total_cost - input_startup_cost)
+                               * offset_rows / input_rows;
+               *rows -= offset_rows;
+               if (*rows < 1)
+                       *rows = 1;
        }
 
        if (count_est != 0)
@@ -3615,19 +3640,17 @@ create_limit_path(PlannerInfo *root, RelOptInfo *rel,
                if (count_est > 0)
                        count_rows = (double) count_est;
                else
-                       count_rows = clamp_row_est(subpath->rows * 0.10);
-               if (count_rows > pathnode->path.rows)
-                       count_rows = pathnode->path.rows;
-               if (subpath->rows > 0)
-                       pathnode->path.total_cost = pathnode->path.startup_cost +
-                               (subpath->total_cost - subpath->startup_cost)
-                               * count_rows / subpath->rows;
-               pathnode->path.rows = count_rows;
-               if (pathnode->path.rows < 1)
-                       pathnode->path.rows = 1;
+                       count_rows = clamp_row_est(input_rows * 0.10);
+               if (count_rows > *rows)
+                       count_rows = *rows;
+               if (input_rows > 0)
+                       *total_cost = *startup_cost +
+                               (input_total_cost - input_startup_cost)
+                               * count_rows / input_rows;
+               *rows = count_rows;
+               if (*rows < 1)
+                       *rows = 1;
        }
-
-       return pathnode;
 }
 
 

diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
index 3a803b3fd0087a511df53bc1912d981654fab58a..5b577c12eca65c0d44bcb53589e6b4b93b87bd25 100644 (file)
--- a/src/include/optimizer/pathnode.h
+++ b/src/include/optimizer/pathnode.h
@@ -265,6 +265,9 @@ extern LimitPath *create_limit_path(PlannerInfo *root, RelOptInfo *rel,
                                  Path *subpath,
                                  Node *limitOffset, Node *limitCount,
                                  int64 offset_est, int64 count_est);
+extern void adjust_limit_rows_costs(double *rows,
+                                               Cost *startup_cost, Cost *total_cost,
+                                               int64 offset_est, int64 count_est);
 
 extern Path *reparameterize_path(PlannerInfo *root, Path *path,
                                        Relids required_outer,