Update upstream source from tag 'upstream/6.0.0'master

Update to upstream version '6.0.0'
with Debian dir 5604a80ec1c96ca76f25f40d78e6ef855abec322

1 files changed, 10 insertions, 27 deletions

diff --git a/src/mongo/db/query/plan_cache_key_factory.cpp b/src/mongo/db/query/plan_cache_key_factory.cpp
index c5dbfbd7ea4..d47f1768858 100644
--- a/src/mongo/db/query/plan_cache_key_factory.cpp
+++ b/src/mongo/db/query/plan_cache_key_factory.cpp
@@ -29,29 +29,30 @@
 
 #include "mongo/db/query/plan_cache_key_factory.h"
 
-#include "mongo/db/query/canonical_query_encoder.h"
 #include "mongo/db/query/collection_query_info.h"
 #include "mongo/db/query/planner_ixselect.h"
 #include "mongo/db/s/operation_sharding_state.h"
 
 namespace mongo {
 namespace plan_cache_detail {
+// Delimiters for cache key encoding.
+const char kEncodeDiscriminatorsBegin = '<';
+const char kEncodeDiscriminatorsEnd = '>';
 
 void encodeIndexabilityForDiscriminators(const MatchExpression* tree,
                                          const IndexToDiscriminatorMap& discriminators,
                                          StringBuilder* keyBuilder) {
-
     for (auto&& indexAndDiscriminatorPair : discriminators) {
         *keyBuilder << indexAndDiscriminatorPair.second.isMatchCompatibleWithIndex(tree);
     }
 }
 
-void encodeIndexabilityRecursive(const MatchExpression* tree,
-                                 const PlanCacheIndexabilityState& indexabilityState,
-                                 StringBuilder* keyBuilder) {
+void encodeIndexability(const MatchExpression* tree,
+                        const PlanCacheIndexabilityState& indexabilityState,
+                        StringBuilder* keyBuilder) {
     if (!tree->path().empty()) {
         const IndexToDiscriminatorMap& discriminators =
-            indexabilityState.getPathDiscriminators(tree->path());
+            indexabilityState.getDiscriminators(tree->path());
         IndexToDiscriminatorMap wildcardDiscriminators =
             indexabilityState.buildWildcardDiscriminators(tree->path());
         if (!discriminators.empty() || !wildcardDiscriminators.empty()) {
@@ -71,26 +72,8 @@ void encodeIndexabilityRecursive(const MatchExpression* tree,
     }
 
     for (size_t i = 0; i < tree->numChildren(); ++i) {
-        encodeIndexabilityRecursive(tree->getChild(i), indexabilityState, keyBuilder);
-    }
-}
-
-void encodeIndexability(const MatchExpression* tree,
-                        const PlanCacheIndexabilityState& indexabilityState,
-                        StringBuilder* keyBuilder) {
-    // Before encoding the indexability of the leaf MatchExpressions, apply the global
-    // discriminators to the expression as a whole. This is for cases such as partial indexes which
-    // must discriminate based on the entire query.
-    const auto& globalDiscriminators = indexabilityState.getGlobalDiscriminators();
-    if (!globalDiscriminators.empty()) {
-        *keyBuilder << kEncodeGlobalDiscriminatorsBegin;
-        for (auto&& indexAndDiscriminatorPair : globalDiscriminators) {
-            *keyBuilder << indexAndDiscriminatorPair.second.isMatchCompatibleWithIndex(tree);
-        }
-        *keyBuilder << kEncodeGlobalDiscriminatorsEnd;
+        encodeIndexability(tree->getChild(i), indexabilityState, keyBuilder);
     }
-
-    encodeIndexabilityRecursive(tree, indexabilityState, keyBuilder);
 }
 
 PlanCacheKeyInfo makePlanCacheKeyInfo(const CanonicalQuery& query,
@@ -128,8 +111,8 @@ boost::optional<Timestamp> computeNewestVisibleIndexTimestamp(OperationContext*
 
     Timestamp currentNewestVisible = Timestamp::min();
 
-    auto ii = collection->getIndexCatalog()->getIndexIterator(
-        opCtx, IndexCatalog::InclusionPolicy::kReady | IndexCatalog::InclusionPolicy::kUnfinished);
+    std::unique_ptr<IndexCatalog::IndexIterator> ii =
+        collection->getIndexCatalog()->getIndexIterator(opCtx, /*includeUnfinishedIndexes*/ true);
     while (ii->more()) {
         const IndexCatalogEntry* ice = ii->next();
         auto minVisibleSnapshot = ice->getMinimumVisibleSnapshot();