Provide a planner hook at a suitable place for creating upper-rel Paths.

In the initial revision of the upper-planner pathification work, the only
available way for an FDW or custom-scan provider to inject Paths
representing post-scan-join processing was to insert them during scan-level
GetForeignPaths or similar processing.  While that's not impossible, it'd
require quite a lot of duplicative processing to look forward and see if
the extension would be capable of implementing the whole query.  To improve
matters for custom-scan providers, provide a hook function at the point
where the core code is about to start filling in upperrel Paths.  At this
point Paths are available for the whole scan/join tree, which should reduce
the amount of redundant effort considerably.

(An alternative design that was suggested was to provide a separate hook
for each post-scan-join processing step, but that seems messy and not
clearly more useful.)

Following our time-honored tradition, there's no documentation for this
hook outside the source code.

As-is, this hook is only meant for custom scan providers, which we can't
assume very much about.  A followon patch will implement an FDW callback
to let FDWs do the same thing in a somewhat more structured fashion.

diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c
index f3a0a44fd889df7bc87532c205e3263f7c23d3ca..d11f44e64d530cb9bb77486d08d276ac8bffea6c 100644 (file)
--- a/src/backend/optimizer/plan/planner.c
+++ b/src/backend/optimizer/plan/planner.c
@@ -62,6 +62,9 @@ int           force_parallel_mode = FORCE_PARALLEL_OFF;
 /* Hook for plugins to get control in planner() */
 planner_hook_type planner_hook = NULL;
 
+/* Hook for plugins to get control before grouping_planner plans upper rels */
+create_upper_paths_hook_type create_upper_paths_hook = NULL;
+
 
 /* Expression kind codes for preprocess_expression */
 #define EXPRKIND_QUAL          0
@@ -459,6 +462,7 @@ subquery_planner(PlannerGlobal *glob, Query *parse,
    root->append_rel_list = NIL;
    root->rowMarks = NIL;
    memset(root->upper_rels, 0, sizeof(root->upper_rels));
+   memset(root->upper_targets, 0, sizeof(root->upper_targets));
    root->processed_tlist = NIL;
    root->grouping_map = NULL;
    root->minmax_aggs = NIL;
@@ -1736,6 +1740,28 @@ grouping_planner(PlannerInfo *root, bool inheritance_update,
            }
        }
 
+       /*
+        * Save the various upper-rel PathTargets we just computed into
+        * root->upper_targets[].  The core code doesn't use this, but it
+        * provides a convenient place for extensions to get at the info.  For
+        * consistency, we save all the intermediate targets, even though some
+        * of the corresponding upperrels might not be needed for this query.
+        */
+       root->upper_targets[UPPERREL_FINAL] = final_target;
+       root->upper_targets[UPPERREL_WINDOW] = sort_input_target;
+       root->upper_targets[UPPERREL_GROUP_AGG] = grouping_target;
+
+       /*
+        * Let extensions, particularly CustomScan providers, consider
+        * injecting extension Paths into the query's upperrels, where they
+        * will compete with the Paths we create below.  We pass the final
+        * scan/join rel because that's not so easily findable from the
+        * PlannerInfo struct; anything else the hook wants to know should be
+        * obtainable via "root".
+        */
+       if (create_upper_paths_hook)
+           (*create_upper_paths_hook) (root, current_rel);
+
        /*
         * If we have grouping and/or aggregation, consider ways to implement
         * that.  We build a new upperrel representing the output of this

diff --git a/src/backend/optimizer/prep/prepjointree.c b/src/backend/optimizer/prep/prepjointree.c
index c8d5c66b396cdde4d144d8539c858bdfdf60061d..75577bce2ca02e56cb010d2161c85c8711967e0f 100644 (file)
--- a/src/backend/optimizer/prep/prepjointree.c
+++ b/src/backend/optimizer/prep/prepjointree.c
@@ -909,6 +909,7 @@ pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
    subroot->append_rel_list = NIL;
    subroot->rowMarks = NIL;
    memset(subroot->upper_rels, 0, sizeof(subroot->upper_rels));
+   memset(subroot->upper_targets, 0, sizeof(subroot->upper_targets));
    subroot->processed_tlist = NIL;
    subroot->grouping_map = NULL;
    subroot->minmax_aggs = NIL;

diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index b48a6183dc2cbedb0aa97d7a0846b57c685abbbd..503269693bac3c1ba23b8668dddb1490ea68a3fb 100644 (file)
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -263,6 +263,9 @@ typedef struct PlannerInfo
    /* Use fetch_upper_rel() to get any particular upper rel */
    List       *upper_rels[UPPERREL_FINAL + 1]; /* upper-rel RelOptInfos */
 
+   /* Result tlists chosen by grouping_planner for upper-stage processing */
+   struct PathTarget *upper_targets[UPPERREL_FINAL + 1];
+
    /*
     * grouping_planner passes back its final processed targetlist here, for
     * use in relabeling the topmost tlist of the finished Plan.

diff --git a/src/include/optimizer/planner.h b/src/include/optimizer/planner.h
index 3fb7cb58cbd77d2eedf6ce00ae40fd048cafb9b2..a95e73fa93b4e36f83dd0c79b8b3b2160ec87729 100644 (file)
--- a/src/include/optimizer/planner.h
+++ b/src/include/optimizer/planner.h
@@ -24,6 +24,11 @@ typedef PlannedStmt *(*planner_hook_type) (Query *parse,
                                                  ParamListInfo boundParams);
 extern PGDLLIMPORT planner_hook_type planner_hook;
 
+/* Hook for plugins to get control before grouping_planner plans upper rels */
+typedef void (*create_upper_paths_hook_type) (PlannerInfo *root,
+                                                 RelOptInfo *scan_join_rel);
+extern PGDLLIMPORT create_upper_paths_hook_type create_upper_paths_hook;
+
 
 extern PlannedStmt *planner(Query *parse, int cursorOptions,
        ParamListInfo boundParams);