SERVER-50728 Use QuerySolution to generate explain output at queryPlanner verbosity in SBE

24 files changed, 383 insertions, 49 deletions

diff --git a/src/mongo/db/query/classic_stage_builder.cpp b/src/mongo/db/query/classic_stage_builder.cpp
index a6ed5c573ed..39a872951f5 100644
--- a/src/mongo/db/query/classic_stage_builder.cpp
+++ b/src/mongo/db/query/classic_stage_builder.cpp
@@ -128,7 +128,7 @@ std::unique_ptr<PlanStage> ClassicStageBuilder::build(const QuerySolutionNode* r
                 _ws,
                 SortPattern{snDefault->pattern, _cq.getExpCtx()},
                 snDefault->limit,
-                internalQueryMaxBlockingSortMemoryUsageBytes.load(),
+                snDefault->maxMemoryUsageBytes,
                 snDefault->addSortKeyMetadata,
                 std::move(childStage));
         }
@@ -140,7 +140,7 @@ std::unique_ptr<PlanStage> ClassicStageBuilder::build(const QuerySolutionNode* r
                 _ws,
                 SortPattern{snSimple->pattern, _cq.getExpCtx()},
                 snSimple->limit,
-                internalQueryMaxBlockingSortMemoryUsageBytes.load(),
+                snSimple->maxMemoryUsageBytes,
                 snSimple->addSortKeyMetadata,
                 std::move(childStage));
         }
diff --git a/src/mongo/db/query/get_executor.cpp b/src/mongo/db/query/get_executor.cpp
index b38296378fe..d28dd909032 100644
--- a/src/mongo/db/query/get_executor.cpp
+++ b/src/mongo/db/query/get_executor.cpp
@@ -226,6 +226,7 @@ IndexEntry indexEntryFromIndexCatalogEntry(OperationContext* opCtx,
 
     return {desc->keyPattern(),
             desc->getIndexType(),
+            desc->version(),
             isMultikey,
             // The fixed-size vector of multikey paths stored in the index catalog.
             ice.getMultikeyPaths(opCtx),
diff --git a/src/mongo/db/query/get_executor_test.cpp b/src/mongo/db/query/get_executor_test.cpp
index 33f22f6ffed..40da9d86e8e 100644
--- a/src/mongo/db/query/get_executor_test.cpp
+++ b/src/mongo/db/query/get_executor_test.cpp
@@ -134,6 +134,7 @@ void testAllowedIndices(std::vector<IndexEntry> indexes,
 IndexEntry buildSimpleIndexEntry(const BSONObj& kp, const std::string& indexName) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
@@ -155,6 +156,7 @@ IndexEntry buildWildcardIndexEntry(const BSONObj& kp,
                                    const std::string& indexName) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
diff --git a/src/mongo/db/query/index_bounds_builder_test.cpp b/src/mongo/db/query/index_bounds_builder_test.cpp
index 2d3ca2d0ac5..4c141b52ee2 100644
--- a/src/mongo/db/query/index_bounds_builder_test.cpp
+++ b/src/mongo/db/query/index_bounds_builder_test.cpp
@@ -961,6 +961,7 @@ TEST_F(IndexBoundsBuilderTest, ExistsTrueSparse) {
     IndexEntry testIndex =
         IndexEntry(keyPattern,
                    IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                   IndexDescriptor::kLatestIndexVersion,
                    false,  // multikey
                    {},
                    {},
diff --git a/src/mongo/db/query/index_bounds_builder_test.h b/src/mongo/db/query/index_bounds_builder_test.h
index 1080abe7198..f3abf8c212c 100644
--- a/src/mongo/db/query/index_bounds_builder_test.h
+++ b/src/mongo/db/query/index_bounds_builder_test.h
@@ -55,6 +55,7 @@ public:
     IndexEntry buildSimpleIndexEntry(const BSONObj& kp = BSONObj()) {
         return {kp,
                 IndexNames::nameToType(IndexNames::findPluginName(kp)),
+                IndexDescriptor::kLatestIndexVersion,
                 false,
                 {},
                 {},
diff --git a/src/mongo/db/query/index_entry.h b/src/mongo/db/query/index_entry.h
index 487e8c6853d..7c7ba04a532 100644
--- a/src/mongo/db/query/index_entry.h
+++ b/src/mongo/db/query/index_entry.h
@@ -33,6 +33,7 @@
 #include <string>
 
 #include "mongo/db/field_ref.h"
+#include "mongo/db/index/index_descriptor.h"
 #include "mongo/db/index/multikey_paths.h"
 #include "mongo/db/index_names.h"
 #include "mongo/db/jsobj.h"
@@ -149,6 +150,7 @@ struct CoreIndexInfo {
 struct IndexEntry : CoreIndexInfo {
     IndexEntry(const BSONObj& kp,
                IndexType type,
+               IndexDescriptor::IndexVersion version,
                bool mk,
                const MultikeyPaths& mkp,
                std::set<FieldRef> multikeyPathSet,
@@ -160,6 +162,7 @@ struct IndexEntry : CoreIndexInfo {
                const CollatorInterface* ci,
                const WildcardProjection* wildcardProjection)
         : CoreIndexInfo(kp, type, sp, std::move(ident), fe, ci, wildcardProjection),
+          version(version),
           multikey(mk),
           multikeyPaths(mkp),
           multikeyPathSet(std::move(multikeyPathSet)),
@@ -224,6 +227,7 @@ struct IndexEntry : CoreIndexInfo {
             sizeof(*this);
     }
 
+    IndexDescriptor::IndexVersion version;
     bool multikey;
 
     // If non-empty, 'multikeyPaths' is a vector with size equal to the number of elements in the
diff --git a/src/mongo/db/query/index_entry_test.cpp b/src/mongo/db/query/index_entry_test.cpp
index 6f80c6c8670..b52a429833f 100644
--- a/src/mongo/db/query/index_entry_test.cpp
+++ b/src/mongo/db/query/index_entry_test.cpp
@@ -45,6 +45,7 @@ IndexEntry makeIndexEntry(BSONObj keyPattern, MultikeyPaths multiKeyPaths) {
 
     return {keyPattern,
             IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+            IndexDescriptor::kLatestIndexVersion,
             multiKey,
             multiKeyPaths,
             {},
diff --git a/src/mongo/db/query/plan_cache_indexability_test.cpp b/src/mongo/db/query/plan_cache_indexability_test.cpp
index f76a7797e1c..af7677a8cd5 100644
--- a/src/mongo/db/query/plan_cache_indexability_test.cpp
+++ b/src/mongo/db/query/plan_cache_indexability_test.cpp
@@ -71,6 +71,7 @@ auto makeWildcardEntry(BSONObj keyPattern, const MatchExpression* filterExpr = n
         WildcardKeyGenerator::createProjectionExecutor(keyPattern, {}));
     return std::make_pair(IndexEntry(keyPattern,
                                      IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                                     IndexDescriptor::kLatestIndexVersion,
                                      false,  // multikey
                                      {},
                                      {},
@@ -91,6 +92,7 @@ TEST(PlanCacheIndexabilityTest, SparseIndexSimple) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -131,6 +133,7 @@ TEST(PlanCacheIndexabilityTest, SparseIndexCompound) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -178,6 +181,7 @@ TEST(PlanCacheIndexabilityTest, PartialIndexSimple) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -227,6 +231,7 @@ TEST(PlanCacheIndexabilityTest, PartialIndexAnd) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -289,6 +294,7 @@ TEST(PlanCacheIndexabilityTest, MultiplePartialIndexes) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern_a,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern_a)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -301,6 +307,7 @@ TEST(PlanCacheIndexabilityTest, MultiplePartialIndexes) {
                     nullptr),
          IndexEntry(keyPattern_b,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern_b)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -374,6 +381,7 @@ TEST(PlanCacheIndexabilityTest, IndexNeitherSparseNorPartial) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
@@ -395,6 +403,7 @@ TEST(PlanCacheIndexabilityTest, DiscriminatorForCollationIndicatesWhenCollations
     auto keyPattern = BSON("a" << 1);
     IndexEntry entry(keyPattern,
                      IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                     IndexDescriptor::kLatestIndexVersion,
                      false,  // multikey
                      {},
                      {},
@@ -485,6 +494,7 @@ TEST(PlanCacheIndexabilityTest, CompoundIndexCollationDiscriminator) {
     state.updateDiscriminators(
         {IndexEntry(keyPattern,
                     IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                    IndexDescriptor::kLatestIndexVersion,
                     false,  // multikey
                     {},
                     {},
diff --git a/src/mongo/db/query/plan_cache_test.cpp b/src/mongo/db/query/plan_cache_test.cpp
index 1535f24f10b..57f673301fc 100644
--- a/src/mongo/db/query/plan_cache_test.cpp
+++ b/src/mongo/db/query/plan_cache_test.cpp
@@ -248,6 +248,7 @@ std::pair<IndexEntry, std::unique_ptr<WildcardProjection>> makeWildcardEntry(BSO
         WildcardKeyGenerator::createProjectionExecutor(keyPattern, {}));
     return {IndexEntry(keyPattern,
                        IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                       IndexDescriptor::kLatestIndexVersion,
                        false,  // multikey
                        {},
                        {},
@@ -903,6 +904,7 @@ protected:
         params.indices.push_back(
             IndexEntry(keyPattern,
                        IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                       IndexDescriptor::kLatestIndexVersion,
                        multikey,
                        {},
                        {},
@@ -919,6 +921,7 @@ protected:
         params.indices.push_back(
             IndexEntry(keyPattern,
                        IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                       IndexDescriptor::kLatestIndexVersion,
                        multikey,
                        {},
                        {},
@@ -934,6 +937,7 @@ protected:
     void addIndex(BSONObj keyPattern, const std::string& indexName, CollatorInterface* collator) {
         IndexEntry entry(keyPattern,
                          IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                         IndexDescriptor::kLatestIndexVersion,
                          false,
                          {},
                          {},
diff --git a/src/mongo/db/query/plan_explainer.h b/src/mongo/db/query/plan_explainer.h
index 9201418954a..c060affb083 100644
--- a/src/mongo/db/query/plan_explainer.h
+++ b/src/mongo/db/query/plan_explainer.h
@@ -36,6 +36,12 @@
 
 namespace mongo {
 /**
+ * The maximum size of a serialized BSON document that details the plan selected by the query
+ * planner.
+ */
+static constexpr int kMaxExplainStatsBSONSizeMB = 10 * 1024 * 1024;
+
+/**
  * This interface defines an API to provide information on the execution plans generated by the
  * query planner for a user query in various formats.
  */
diff --git a/src/mongo/db/query/plan_explainer_impl.cpp b/src/mongo/db/query/plan_explainer_impl.cpp
index f55cf9776a8..41a5757f044 100644
--- a/src/mongo/db/query/plan_explainer_impl.cpp
+++ b/src/mongo/db/query/plan_explainer_impl.cpp
@@ -166,40 +166,6 @@ size_t getDocsExamined(StageType type, const SpecificStats* specific) {
 }
 
 /**
- * Adds the path-level multikey information to the explain output in a field called "multiKeyPaths".
- * The value associated with the "multiKeyPaths" field is an object with keys equal to those in the
- * index key pattern and values equal to an array of strings corresponding to paths that cause the
- * index to be multikey.
- *
- * For example, with the index {'a.b': 1, 'a.c': 1} where the paths "a" and "a.b" cause the
- * index to be multikey, we'd have {'multiKeyPaths': {'a.b': ['a', 'a.b'], 'a.c': ['a']}}.
- *
- * This function should only be called if the associated index supports path-level multikey
- * tracking.
- */
-void appendMultikeyPaths(const BSONObj& keyPattern,
-                         const MultikeyPaths& multikeyPaths,
-                         BSONObjBuilder* bob) {
-    BSONObjBuilder subMultikeyPaths(bob->subobjStart("multiKeyPaths"));
-
-    size_t i = 0;
-    for (const auto& keyElem : keyPattern) {
-        const FieldRef path{keyElem.fieldNameStringData()};
-
-        BSONArrayBuilder arrMultikeyComponents(
-            subMultikeyPaths.subarrayStart(keyElem.fieldNameStringData()));
-        for (const auto& multikeyComponent : multikeyPaths[i]) {
-            arrMultikeyComponents.append(path.dottedSubstring(0, multikeyComponent + 1));
-        }
-        arrMultikeyComponents.doneFast();
-
-        ++i;
-    }
-
-    subMultikeyPaths.doneFast();
-}
-
-/**
  * Converts the stats tree 'stats' into a corresponding BSON object containing explain information.
  *
  * Generates the BSON stats at a verbosity specified by 'verbosity'.
@@ -211,10 +177,9 @@ void statsToBSON(const PlanStageStats& stats,
     invariant(bob);
     invariant(topLevelBob);
 
-    // Stop as soon as the BSON object we're building exceeds 10 MB.
-    static const int kMaxStatsBSONSize = 10 * 1024 * 1024;
-    if (topLevelBob->len() > kMaxStatsBSONSize) {
-        bob->append("warning", "stats tree exceeded 10 MB");
+    // Stop as soon as the BSON object we're building exceeds the limit.
+    if (topLevelBob->len() > kMaxExplainStatsBSONSizeMB) {
+        bob->append("warning", "stats tree exceeded BSON size limit for explain");
         return;
     }
 
@@ -337,8 +302,8 @@ void statsToBSON(const PlanStageStats& stats,
         bob->append("indexVersion", spec->indexVersion);
         bob->append("direction", spec->direction > 0 ? "forward" : "backward");
 
-        if ((topLevelBob->len() + spec->indexBounds.objsize()) > kMaxStatsBSONSize) {
-            bob->append("warning", "index bounds omitted due to BSON size limit");
+        if ((topLevelBob->len() + spec->indexBounds.objsize()) > kMaxExplainStatsBSONSizeMB) {
+            bob->append("warning", "index bounds omitted due to BSON size limit for explain");
         } else {
             bob->append("indexBounds", spec->indexBounds);
         }
@@ -403,8 +368,8 @@ void statsToBSON(const PlanStageStats& stats,
         bob->append("indexVersion", spec->indexVersion);
         bob->append("direction", spec->direction > 0 ? "forward" : "backward");
 
-        if ((topLevelBob->len() + spec->indexBounds.objsize()) > kMaxStatsBSONSize) {
-            bob->append("warning", "index bounds omitted due to BSON size limit");
+        if ((topLevelBob->len() + spec->indexBounds.objsize()) > kMaxExplainStatsBSONSizeMB) {
+            bob->append("warning", "index bounds omitted due to BSON size limit for explain");
         } else {
             bob->append("indexBounds", spec->indexBounds);
         }
@@ -549,6 +514,28 @@ PlanSummaryStats collectExecutionStatsSummary(const PlanStageStats* stats) {
 }
 }  // namespace
 
+void appendMultikeyPaths(const BSONObj& keyPattern,
+                         const MultikeyPaths& multikeyPaths,
+                         BSONObjBuilder* bob) {
+    BSONObjBuilder subMultikeyPaths(bob->subobjStart("multiKeyPaths"));
+
+    size_t i = 0;
+    for (const auto& keyElem : keyPattern) {
+        const FieldRef path{keyElem.fieldNameStringData()};
+
+        BSONArrayBuilder arrMultikeyComponents(
+            subMultikeyPaths.subarrayStart(keyElem.fieldNameStringData()));
+        for (const auto& multikeyComponent : multikeyPaths[i]) {
+            arrMultikeyComponents.append(path.dottedSubstring(0, multikeyComponent + 1));
+        }
+        arrMultikeyComponents.doneFast();
+
+        ++i;
+    }
+
+    subMultikeyPaths.doneFast();
+}
+
 bool PlanExplainerImpl::isMultiPlan() const {
     return getStageByType(_root, StageType::STAGE_MULTI_PLAN) != nullptr;
 }
diff --git a/src/mongo/db/query/plan_explainer_impl.h b/src/mongo/db/query/plan_explainer_impl.h
index 1886441f819..0d18d19a17a 100644
--- a/src/mongo/db/query/plan_explainer_impl.h
+++ b/src/mongo/db/query/plan_explainer_impl.h
@@ -62,4 +62,20 @@ private:
  * found.
  */
 PlanStage* getStageByType(PlanStage* root, StageType type);
+
+/**
+ * Adds the path-level multikey information to the explain output in a field called "multiKeyPaths".
+ * The value associated with the "multiKeyPaths" field is an object with keys equal to those in the
+ * index key pattern and values equal to an array of strings corresponding to paths that cause the
+ * index to be multikey.
+ *
+ * For example, with the index {'a.b': 1, 'a.c': 1} where the paths "a" and "a.b" cause the
+ * index to be multikey, we'd have {'multiKeyPaths': {'a.b': ['a', 'a.b'], 'a.c': ['a']}}.
+ *
+ * This function should only be called if the associated index supports path-level multikey
+ * tracking.
+ */
+void appendMultikeyPaths(const BSONObj& keyPattern,
+                         const MultikeyPaths& multikeyPaths,
+                         BSONObjBuilder* bob);
 }  // namespace mongo
diff --git a/src/mongo/db/query/plan_explainer_sbe.cpp b/src/mongo/db/query/plan_explainer_sbe.cpp
index c91addc4199..08d5db7b6a9 100644
--- a/src/mongo/db/query/plan_explainer_sbe.cpp
+++ b/src/mongo/db/query/plan_explainer_sbe.cpp
@@ -33,9 +33,246 @@
 
 #include <queue>
 
+#include "mongo/db/fts/fts_query_impl.h"
 #include "mongo/db/keypattern.h"
+#include "mongo/db/query/plan_explainer_impl.h"
+#include "mongo/db/query/projection_ast_util.h"
 
 namespace mongo {
+namespace {
+void statsToBSON(const QuerySolutionNode* node,
+                 const sbe::PlanStageStats* stats,
+                 ExplainOptions::Verbosity verbosity,
+                 BSONObjBuilder* bob,
+                 const BSONObjBuilder* topLevelBob) {
+    invariant(bob);
+    invariant(topLevelBob);
+    invariant(verbosity < ExplainOptions::Verbosity::kExecStats || stats);
+
+    // Stop as soon as the BSON object we're building exceeds the limit.
+    if (topLevelBob->len() > kMaxExplainStatsBSONSizeMB) {
+        bob->append("warning", "stats tree exceeded BSON size limit for explain");
+        return;
+    }
+
+    bob->append("stage", stageTypeToString(node->getType()));
+    bob->appendNumber("planNodeId", static_cast<size_t>(node->nodeId()));
+
+    // Display the BSON representation of the filter, if there is one.
+    if (node->filter) {
+        bob->append("filter", node->filter->serialize());
+    }
+
+    // Some top-level exec stats get pulled out of the root stage.
+    if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+        // TODO SERVER-51409.
+    }
+
+    // Stage-specific stats.
+    switch (node->getType()) {
+        case STAGE_AND_HASH: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_AND_SORTED: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_COLLSCAN: {
+            auto csn = static_cast<const CollectionScanNode*>(node);
+            bob->append("direction", csn->direction > 0 ? "forward" : "backward");
+            if (csn->minTs) {
+                bob->append("minTs", *csn->minTs);
+            }
+            if (csn->maxTs) {
+                bob->append("maxTs", *csn->maxTs);
+            }
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+
+        case STAGE_ENSURE_SORTED: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_FETCH: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+
+        case STAGE_GEO_NEAR_2D: {
+            auto geo2d = static_cast<const GeoNear2DNode*>(node);
+
+            bob->append("keyPattern", geo2d->index.keyPattern);
+            bob->append("indexName", geo2d->index.identifier.catalogName);
+            bob->append("indexVersion", geo2d->index.version);
+
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_GEO_NEAR_2DSPHERE: {
+            auto geo2dsphere = static_cast<const GeoNear2DSphereNode*>(node);
+
+            bob->append("keyPattern", geo2dsphere->index.keyPattern);
+            bob->append("indexName", geo2dsphere->index.identifier.catalogName);
+            bob->append("indexVersion", geo2dsphere->index.version);
+
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_IXSCAN: {
+            auto ixn = static_cast<const IndexScanNode*>(node);
+
+            bob->append("keyPattern", ixn->index.keyPattern);
+            bob->append("indexName", ixn->index.identifier.catalogName);
+            auto collation =
+                ixn->index.infoObj.getObjectField(IndexDescriptor::kCollationFieldName);
+            if (!collation.isEmpty()) {
+                bob->append("collation", collation);
+            }
+            bob->appendBool("isMultiKey", ixn->index.multikey);
+            if (!ixn->index.multikeyPaths.empty()) {
+                appendMultikeyPaths(ixn->index.keyPattern, ixn->index.multikeyPaths, bob);
+            }
+            bob->appendBool("isUnique", ixn->index.unique);
+            bob->appendBool("isSparse", ixn->index.sparse);
+            bob->appendBool("isPartial", ixn->index.filterExpr != nullptr);
+            bob->append("indexVersion", static_cast<int>(ixn->index.version));
+            bob->append("direction", ixn->direction > 0 ? "forward" : "backward");
+
+            auto bounds = ixn->bounds.toBSON();
+            if (topLevelBob->len() + bounds.objsize() > kMaxExplainStatsBSONSizeMB) {
+                bob->append("warning", "index bounds omitted due to BSON size limit for explain");
+            } else {
+                bob->append("indexBounds", bounds);
+            }
+
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_OR: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_LIMIT: {
+            auto ln = static_cast<const LimitNode*>(node);
+            bob->appendNumber("limitAmount", ln->limit);
+            break;
+        }
+        case STAGE_PROJECTION_DEFAULT:
+        case STAGE_PROJECTION_SIMPLE:
+        case STAGE_PROJECTION_COVERED: {
+            auto pn = static_cast<const ProjectionNode*>(node);
+            bob->append("transformBy", projection_ast::astToDebugBSON(pn->proj.root()));
+            break;
+        }
+        case STAGE_SHARDING_FILTER: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_SKIP: {
+            auto sn = static_cast<const SkipNode*>(node);
+            bob->appendNumber("skipAmount", sn->skip);
+        }
+        case STAGE_SORT_SIMPLE:
+        case STAGE_SORT_DEFAULT: {
+            auto sn = static_cast<const SortNode*>(node);
+            bob->append("sortPattern", sn->pattern);
+            bob->appendIntOrLL("memLimit", sn->maxMemoryUsageBytes);
+
+            if (sn->limit > 0) {
+                bob->appendIntOrLL("limitAmount", sn->limit);
+            }
+
+            bob->append("type", node->getType() == STAGE_SORT_SIMPLE ? "simple" : "default");
+
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_SORT_MERGE: {
+            auto smn = static_cast<const MergeSortNode*>(node);
+            bob->append("sortPattern", smn->sort);
+
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_TEXT: {
+            auto tn = static_cast<const TextNode*>(node);
+
+            bob->append("indexPrefix", tn->indexPrefix);
+            bob->append("indexName", tn->index.identifier.catalogName);
+            auto ftsQuery = dynamic_cast<fts::FTSQueryImpl*>(tn->ftsQuery.get());
+            invariant(ftsQuery);
+            bob->append("parsedTextQuery", ftsQuery->toBSON());
+            bob->append("textIndexVersion", tn->index.version);
+        }
+        case STAGE_TEXT_MATCH: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+        case STAGE_TEXT_OR: {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                // TODO SERVER-51409.
+            }
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    // We're done if there are no children.
+    if (node->children.empty()) {
+        return;
+    }
+
+    // If there's just one child (a common scenario), avoid making an array. This makes
+    // the output more readable by saving a level of nesting. Name the field 'inputStage'
+    // rather than 'inputStages'.
+    if (node->children.size() == 1) {
+        BSONObjBuilder childBob;
+        statsToBSON(node->children[0], stats, verbosity, &childBob, topLevelBob);
+        bob->append("inputStage", childBob.obj());
+        return;
+    }
+
+    // There is more than one child. Recursively call statsToBSON(...) on each
+    // of them and add them to the 'inputStages' array.
+    BSONArrayBuilder childrenBob(bob->subarrayStart("inputStages"));
+    for (auto&& child : node->children) {
+        BSONObjBuilder childBob(childrenBob.subobjStart());
+        statsToBSON(child, stats, verbosity, &childBob, topLevelBob);
+    }
+    childrenBob.doneFast();
+}
+}  // namespace
+
 std::string PlanExplainerSBE::getPlanSummary() const {
     if (!_solution) {
         return {};
@@ -181,14 +418,51 @@ void PlanExplainerSBE::getSummaryStats(PlanSummaryStats* statsOut) const {
 
 PlanExplainer::PlanStatsDetails PlanExplainerSBE::getWinningPlanStats(
     ExplainOptions::Verbosity verbosity) const {
-    // TODO: SERVER-50728
-    return {{}, PlanSummaryStats{}};
+    invariant(_root);
+    invariant(_solution);
+
+    auto&& [stats, summary] = [&]()
+        -> std::pair<std::unique_ptr<sbe::PlanStageStats>, boost::optional<PlanSummaryStats>> {
+        if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+            auto stats = _root->getStats();
+            // TODO: SERVER-51409 add support for PlanSummaryStats.
+            return {std::move(stats), PlanSummaryStats{}};
+        }
+        return {};
+    }();
+
+    BSONObjBuilder bob;
+    statsToBSON(_solution->root(), stats.get(), verbosity, &bob, &bob);
+    return {bob.obj(), std::move(summary)};
 }
 
 std::vector<PlanExplainer::PlanStatsDetails> PlanExplainerSBE::getRejectedPlansStats(
     ExplainOptions::Verbosity verbosity) const {
-    // TODO: SERVER-50728
-    return {};
+    if (_rejectedCandidates.empty()) {
+        return {};
+    }
+
+    std::vector<PlanStatsDetails> res;
+    res.reserve(_rejectedCandidates.size());
+    for (auto&& candidate : _rejectedCandidates) {
+        invariant(candidate.root);
+        invariant(candidate.solution);
+
+        auto&& [stats, summary] = [&]()
+            -> std::pair<std::unique_ptr<sbe::PlanStageStats>, boost::optional<PlanSummaryStats>> {
+            if (verbosity >= ExplainOptions::Verbosity::kExecStats) {
+                auto stats = candidate.root->getStats();
+                // TODO: SERVER-51409 add support for PlanSummaryStats.
+                return {std::move(stats), PlanSummaryStats{}};
+            }
+            return {};
+        }();
+
+        BSONObjBuilder bob;
+        statsToBSON(candidate.solution->root(), stats.get(), verbosity, &bob, &bob);
+        res.push_back({bob.obj(), std::move(summary)});
+    }
+    return res;
 }
 
 std::vector<PlanExplainer::PlanStatsDetails> PlanExplainerSBE::getCachedPlanStats(
diff --git a/src/mongo/db/query/planner_analysis_test.cpp b/src/mongo/db/query/planner_analysis_test.cpp
index 3a6049e3143..d980dcb9444 100644
--- a/src/mongo/db/query/planner_analysis_test.cpp
+++ b/src/mongo/db/query/planner_analysis_test.cpp
@@ -47,6 +47,7 @@ namespace {
 IndexEntry buildSimpleIndexEntry(const BSONObj& kp) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
diff --git a/src/mongo/db/query/planner_ixselect_test.cpp b/src/mongo/db/query/planner_ixselect_test.cpp
index 4dacc6a127b..38402324991 100644
--- a/src/mongo/db/query/planner_ixselect_test.cpp
+++ b/src/mongo/db/query/planner_ixselect_test.cpp
@@ -197,6 +197,7 @@ void findRelevantTaggedNodePathsAndIndices(MatchExpression* root,
 IndexEntry buildSimpleIndexEntry(const BSONObj& kp) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
@@ -1069,6 +1070,7 @@ auto makeIndexEntry(BSONObj keyPattern,
         });
     return std::make_pair(IndexEntry(keyPattern,
                                      IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                                     IndexDescriptor::kLatestIndexVersion,
                                      multiKey,
                                      multiKeyPaths,
                                      multiKeyPathSet,
diff --git a/src/mongo/db/query/planner_wildcard_helpers.cpp b/src/mongo/db/query/planner_wildcard_helpers.cpp
index 837180ff85b..395d0253e04 100644
--- a/src/mongo/db/query/planner_wildcard_helpers.cpp
+++ b/src/mongo/db/query/planner_wildcard_helpers.cpp
@@ -397,6 +397,7 @@ void expandWildcardIndexEntry(const IndexEntry& wildcardIndex,
 
         IndexEntry entry(BSON(fieldName << wildcardIndex.keyPattern.firstElement()),
                          IndexType::INDEX_WILDCARD,
+                         IndexDescriptor::kLatestIndexVersion,
                          isMultikey,
                          std::move(multikeyPaths),
                          // Expanded index entries always use the fixed-size multikey paths
diff --git a/src/mongo/db/query/query_planner_operator_test.cpp b/src/mongo/db/query/query_planner_operator_test.cpp
index f09182c15db..2acb55d5687 100644
--- a/src/mongo/db/query/query_planner_operator_test.cpp
+++ b/src/mongo/db/query/query_planner_operator_test.cpp
@@ -396,6 +396,7 @@ TEST_F(QueryPlannerTest, NotEqualsNullInElemMatchObjectSparseMultiKeyAboveElemMa
     auto keyPattern = BSON("a.b.c.d" << 1);
     IndexEntry ind(keyPattern,
                    IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                   IndexDescriptor::kLatestIndexVersion,
                    true,
                    {},
                    {},
@@ -425,6 +426,7 @@ TEST_F(QueryPlannerTest, NotEqualsNullInElemMatchObjectSparseMultiKeyBelowElemMa
     auto keyPattern = BSON("a.b.c.d" << 1);
     IndexEntry ind(keyPattern,
                    IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                   IndexDescriptor::kLatestIndexVersion,
                    true,
                    {},
                    {},
diff --git a/src/mongo/db/query/query_planner_options_test.cpp b/src/mongo/db/query/query_planner_options_test.cpp
index a82a7f405f9..460433db511 100644
--- a/src/mongo/db/query/query_planner_options_test.cpp
+++ b/src/mongo/db/query/query_planner_options_test.cpp
@@ -43,6 +43,7 @@ namespace {
 IndexEntry buildSimpleIndexEntry(const BSONObj& kp, const std::string& indexName) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
diff --git a/src/mongo/db/query/query_planner_test_fixture.cpp b/src/mongo/db/query/query_planner_test_fixture.cpp
index 0bc0a8c8f77..6307f9cc9d3 100644
--- a/src/mongo/db/query/query_planner_test_fixture.cpp
+++ b/src/mongo/db/query/query_planner_test_fixture.cpp
@@ -71,6 +71,7 @@ void QueryPlannerTest::clearState() {
 void QueryPlannerTest::addIndex(BSONObj keyPattern, bool multikey) {
     params.indices.push_back({keyPattern,
                               IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                              IndexDescriptor::kLatestIndexVersion,
                               multikey,
                               {},
                               {},
@@ -86,6 +87,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, bool multikey) {
 void QueryPlannerTest::addIndex(BSONObj keyPattern, bool multikey, bool sparse) {
     params.indices.push_back({keyPattern,
                               IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                              IndexDescriptor::kLatestIndexVersion,
                               multikey,
                               {},
                               {},
@@ -102,6 +104,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, bool multikey, bool sparse,
     params.indices.push_back(
         {keyPattern,
          IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+         IndexDescriptor::kLatestIndexVersion,
          multikey,
          {},
          {},
@@ -117,6 +120,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, bool multikey, bool sparse,
 void QueryPlannerTest::addIndex(BSONObj keyPattern, BSONObj infoObj) {
     params.indices.push_back({keyPattern,
                               IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                              IndexDescriptor::kLatestIndexVersion,
                               false,  // multikey
                               {},
                               {},
@@ -132,6 +136,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, BSONObj infoObj) {
 void QueryPlannerTest::addIndex(BSONObj keyPattern, MatchExpression* filterExpr) {
     params.indices.push_back({keyPattern,
                               IndexNames::nameToType(IndexNames::findPluginName(keyPattern)),
+                              IndexDescriptor::kLatestIndexVersion,
                               false,  // multikey
                               {},
                               {},
@@ -159,6 +164,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, const MultikeyPaths& multike
     const BSONObj infoObj;
     IndexEntry entry(keyPattern,
                      type,
+                     IndexDescriptor::kLatestIndexVersion,
                      multikey,
                      {},
                      {},
@@ -183,6 +189,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern, const CollatorInterface* col
     const BSONObj infoObj;
     IndexEntry entry(keyPattern,
                      type,
+                     IndexDescriptor::kLatestIndexVersion,
                      multikey,
                      {},
                      {},
@@ -209,6 +216,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern,
     const BSONObj infoObj;
     IndexEntry entry(keyPattern,
                      type,
+                     IndexDescriptor::kLatestIndexVersion,
                      multikey,
                      {},
                      {},
@@ -234,6 +242,7 @@ void QueryPlannerTest::addIndex(BSONObj keyPattern,
     const BSONObj infoObj;
     IndexEntry entry(keyPattern,
                      type,
+                     IndexDescriptor::kLatestIndexVersion,
                      multikey,
                      {},
                      {},
diff --git a/src/mongo/db/query/query_planner_wildcard_index_test.cpp b/src/mongo/db/query/query_planner_wildcard_index_test.cpp
index 0494c13cab4..9d0b5b2df06 100644
--- a/src/mongo/db/query/query_planner_wildcard_index_test.cpp
+++ b/src/mongo/db/query/query_planner_wildcard_index_test.cpp
@@ -75,6 +75,7 @@ protected:
 
         params.indices.push_back({std::move(keyPattern),
                                   IndexType::INDEX_WILDCARD,
+                                  IndexDescriptor::kLatestIndexVersion,
                                   isMultikey,
                                   {},  // multikeyPaths
                                   std::move(multikeyFieldRefs),
diff --git a/src/mongo/db/query/query_settings_test.cpp b/src/mongo/db/query/query_settings_test.cpp
index 6a6d0dce66f..15d3bebdccf 100644
--- a/src/mongo/db/query/query_settings_test.cpp
+++ b/src/mongo/db/query/query_settings_test.cpp
@@ -53,6 +53,7 @@ TEST(QuerySettingsTest, AllowedIndicesFilterAllowsIndexesByName) {
     auto keyPat = fromjson("{a:1, b:1}");
     IndexEntry a_idx(keyPat,
                      mongo::IndexNames::nameToType(mongo::IndexNames::findPluginName(keyPat)),
+                     mongo::IndexDescriptor::kLatestIndexVersion,
                      false,
                      {},
                      {},
@@ -65,6 +66,7 @@ TEST(QuerySettingsTest, AllowedIndicesFilterAllowsIndexesByName) {
                      nullptr);
     IndexEntry ab_idx(keyPat,
                       mongo::IndexNames::nameToType(mongo::IndexNames::findPluginName(keyPat)),
+                      mongo::IndexDescriptor::kLatestIndexVersion,
                       false,
                       {},
                       {},
@@ -86,6 +88,7 @@ TEST(QuerySettingsTest, AllowedIndicesFilterAllowsIndexesByKeyPattern) {
     auto keyPat_a = fromjson("{a:1}");
     IndexEntry a_idx(keyPat_a,
                      mongo::IndexNames::nameToType(mongo::IndexNames::findPluginName(keyPat_a)),
+                     mongo::IndexDescriptor::kLatestIndexVersion,
                      false,
                      {},
                      {},
@@ -99,6 +102,7 @@ TEST(QuerySettingsTest, AllowedIndicesFilterAllowsIndexesByKeyPattern) {
     auto keyPat_ab = fromjson("{a:1, b:1}");
     IndexEntry ab_idx(keyPat_ab,
                       mongo::IndexNames::nameToType(mongo::IndexNames::findPluginName(keyPat_ab)),
+                      mongo::IndexDescriptor::kLatestIndexVersion,
                       false,
                       {},
                       {},
diff --git a/src/mongo/db/query/query_solution.h b/src/mongo/db/query/query_solution.h
index 5e4280582f8..7801a3ea18e 100644
--- a/src/mongo/db/query/query_solution.h
+++ b/src/mongo/db/query/query_solution.h
@@ -860,6 +860,11 @@ struct SortNode : public QuerySolutionNodeWithSortSet {
 
     bool addSortKeyMetadata = false;
 
+    // The maximum number of bytes of memory we're willing to use during execution of the sort. If
+    // this limit is exceeded and we're not allowed to spill to disk, the query will fail at
+    // execution time. Otherwise, the data will be spilled to disk.
+    uint64_t maxMemoryUsageBytes = internalQueryMaxBlockingSortMemoryUsageBytes.load();
+
 protected:
     void cloneSortData(SortNode* copy) const;
 
diff --git a/src/mongo/db/query/query_solution_test.cpp b/src/mongo/db/query/query_solution_test.cpp
index e7546a854c9..8763b208fcd 100644
--- a/src/mongo/db/query/query_solution_test.cpp
+++ b/src/mongo/db/query/query_solution_test.cpp
@@ -52,6 +52,7 @@ using namespace mongo;
 IndexEntry buildSimpleIndexEntry(const BSONObj& kp) {
     return {kp,
             IndexNames::nameToType(IndexNames::findPluginName(kp)),
+            IndexDescriptor::kLatestIndexVersion,
             false,
             {},
             {},
diff --git a/src/mongo/db/query/sbe_stage_builder.cpp b/src/mongo/db/query/sbe_stage_builder.cpp
index 717803871ec..cc17cccf974 100644
--- a/src/mongo/db/query/sbe_stage_builder.cpp
+++ b/src/mongo/db/query/sbe_stage_builder.cpp
@@ -315,7 +315,7 @@ std::unique_ptr<sbe::PlanStage> SlotBasedStageBuilder::buildSort(const QuerySolu
                                       std::move(values),
                                       sn->limit ? sn->limit
                                                 : std::numeric_limits<std::size_t>::max(),
-                                      internalQueryMaxBlockingSortMemoryUsageBytes.load(),
+                                      sn->maxMemoryUsageBytes,
                                       _cq.getExpCtx()->allowDiskUse,
                                       _data.trialRunProgressTracker.get(),
                                       root->nodeId());