1 files changed, 22 insertions, 7 deletions
diff --git a/src/mongo/db/query/optimizer/cascades/rewrite_queues.h b/src/mongo/db/query/optimizer/cascades/rewrite_queues.h
index b8e6ec66530..732d338a153 100644
--- a/src/mongo/db/query/optimizer/cascades/rewrite_queues.h
+++ b/src/mongo/db/query/optimizer/cascades/rewrite_queues.h
@@ -33,7 +33,6 @@
 
 #include "mongo/db/query/optimizer/cascades/rewriter_rules.h"
 #include "mongo/db/query/optimizer/node_defs.h"
-#include "mongo/db/query/optimizer/utils/rewriter_utils.h"
 
 namespace mongo::optimizer::cascades {
 
@@ -75,7 +74,7 @@ static constexpr double kDefaultPriority = 10.0;
 struct PhysRewriteEntry {
     PhysRewriteEntry(double priority,
                      PhysicalRewriteType rule,
-                     ABT node,
+                     std::unique_ptr<ABT> node,
                      ChildPropsType childProps,
                      NodeCEMap nodeCEMap);
 
@@ -88,9 +87,15 @@ struct PhysRewriteEntry {
     // Rewrite rule that triggered this entry.
     PhysicalRewriteType _rule;
 
-    ABT _node;
+    // Node we are optimizing. This is typically a single node such as Filter with a
+    // MemoLogicalDelegator child, but could be a more complex tree.
+    std::unique_ptr<ABT> _node;
+    // For each child to optimize, we have associated physical properties. If we are optimizing the
+    // node under new properties (e.g. via enforcement) the map will contain a single entry using
+    // the address of the node itself (as opposed to the children to optimize).
     ChildPropsType _childProps;
 
+    // Optional per-node CE. Used if the node is complex tree.
     NodeCEMap _nodeCEMap;
 };
 
@@ -106,6 +111,13 @@ using PhysRewriteQueue = std::priority_queue<std::unique_ptr<PhysRewriteEntry>,
 void optimizeChildrenNoAssert(PhysRewriteQueue& queue,
                               double priority,
                               PhysicalRewriteType rule,
+                              std::unique_ptr<ABT> node,
+                              ChildPropsType childProps,
+                              NodeCEMap nodeCEMap);
+
+void optimizeChildrenNoAssert(PhysRewriteQueue& queue,
+                              double priority,
+                              PhysicalRewriteType rule,
                               ABT node,
                               ChildPropsType childProps,
                               NodeCEMap nodeCEMap);
@@ -116,7 +128,8 @@ static void optimizeChildren(PhysRewriteQueue& queue,
                              ABT node,
                              ChildPropsType childProps) {
     static_assert(canBePhysicalNode<T>(), "Can only optimize a physical node.");
-    optimizeChildrenNoAssert(queue, priority, rule, std::move(node), std::move(childProps), {});
+    optimizeChildrenNoAssert(
+        queue, priority, rule, std::move(node), std::move(childProps), {} /*nodeCEMap*/);
 }
 
 template <class T, PhysicalRewriteType rule>
@@ -131,7 +144,7 @@ static void optimizeChild(PhysRewriteQueue& queue,
 
 template <class T, PhysicalRewriteType rule>
 static void optimizeChild(PhysRewriteQueue& queue, const double priority, ABT node) {
-    optimizeChildren<T, rule>(queue, priority, std::move(node), {});
+    optimizeChildren<T, rule>(queue, priority, std::move(node), {} /*nodeCEMap*/);
 }
 
 
@@ -140,8 +153,10 @@ void optimizeUnderNewProperties(cascades::PhysRewriteQueue& queue,
                                 const double priority,
                                 ABT child,
                                 properties::PhysProps props) {
-    optimizeChild<FilterNode, rule>(
-        queue, priority, wrapConstFilter(std::move(child)), std::move(props));
+    auto nodePtr = std::make_unique<ABT>(std::move(child));
+    ChildPropsType childProps{{nodePtr.get(), std::move(props)}};
+    optimizeChildrenNoAssert(
+        queue, priority, rule, std::move(nodePtr), std::move(childProps), {} /*nodeCEMap*/);
 }
 
 template <class T, PhysicalRewriteType rule>