Revert "SERVER-23882 Collation should be considered part of a query's shape"

This reverts commit 582818dac41ac01975820c09f79d3b86dc3782cc.

1 files changed, 9 insertions, 49 deletions

diff --git a/src/mongo/db/query/plan_cache_indexability.cpp b/src/mongo/db/query/plan_cache_indexability.cpp
index 442cb222001..066d7a2782b 100644
--- a/src/mongo/db/query/plan_cache_indexability.cpp
+++ b/src/mongo/db/query/plan_cache_indexability.cpp
@@ -35,18 +35,15 @@
 #include "mongo/db/matcher/expression.h"
 #include "mongo/db/matcher/expression_algo.h"
 #include "mongo/db/matcher/expression_leaf.h"
-#include "mongo/db/query/collation/collation_index_key.h"
-#include "mongo/db/query/collation/collator_interface.h"
 #include "mongo/db/query/index_entry.h"
 #include "mongo/stdx/memory.h"
 #include <memory>
 
 namespace mongo {
 
-void PlanCacheIndexabilityState::processSparseIndex(const std::string& indexName,
-                                                    const BSONObj& keyPattern) {
+void PlanCacheIndexabilityState::processSparseIndex(const BSONObj& keyPattern) {
     for (BSONElement elem : keyPattern) {
-        _pathDiscriminatorsMap[elem.fieldNameStringData()][indexName].addDiscriminator(
+        _pathDiscriminatorsMap[elem.fieldNameStringData()].push_back(
             [](const MatchExpression* queryExpr) {
                 if (queryExpr->matchType() == MatchExpression::EQ) {
                     const auto* queryExprEquality =
@@ -62,60 +59,24 @@ void PlanCacheIndexabilityState::processSparseIndex(const std::string& indexName
     }
 }
 
-void PlanCacheIndexabilityState::processPartialIndex(const std::string& indexName,
-                                                     const MatchExpression* filterExpr) {
+void PlanCacheIndexabilityState::processPartialIndex(const MatchExpression* filterExpr) {
     invariant(filterExpr);
     for (size_t i = 0; i < filterExpr->numChildren(); ++i) {
-        processPartialIndex(indexName, filterExpr->getChild(i));
+        processPartialIndex(filterExpr->getChild(i));
     }
     if (!filterExpr->isLogical()) {
-        _pathDiscriminatorsMap[filterExpr->path()][indexName].addDiscriminator(
+        _pathDiscriminatorsMap[filterExpr->path()].push_back(
             [filterExpr](const MatchExpression* queryExpr) {
                 return expression::isSubsetOf(queryExpr, filterExpr);
             });
     }
 }
 
-void PlanCacheIndexabilityState::processIndexCollation(const std::string& indexName,
-                                                       const BSONObj& keyPattern,
-                                                       const CollatorInterface* collator) {
-    for (BSONElement elem : keyPattern) {
-        _pathDiscriminatorsMap[elem.fieldNameStringData()][indexName].addDiscriminator([collator](
-            const MatchExpression* queryExpr) {
-            if (ComparisonMatchExpression::isComparisonMatchExpression(queryExpr)) {
-                const auto* queryExprComparison =
-                    static_cast<const ComparisonMatchExpression*>(queryExpr);
-                const bool collatorsMatch =
-                    CollatorInterface::collatorsMatch(queryExprComparison->getCollator(), collator);
-                const bool isCollatableType =
-                    CollationIndexKey::isCollatableType(queryExprComparison->getData().type());
-                return collatorsMatch || !isCollatableType;
-            }
-
-            if (queryExpr->matchType() == MatchExpression::MATCH_IN) {
-                const auto* queryExprIn = static_cast<const InMatchExpression*>(queryExpr);
-                if (CollatorInterface::collatorsMatch(queryExprIn->getCollator(), collator)) {
-                    return true;
-                }
-                for (const auto& equality : queryExprIn->getEqualities()) {
-                    if (CollationIndexKey::isCollatableType(equality.type())) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-
-            // The predicate never compares strings so it is not affected by collation.
-            return true;
-        });
-    }
-}
-
 namespace {
-const IndexToDiscriminatorMap emptyDiscriminators;
+const IndexabilityDiscriminators emptyDiscriminators;
 }  // namespace
 
-const IndexToDiscriminatorMap& PlanCacheIndexabilityState::getDiscriminators(
+const IndexabilityDiscriminators& PlanCacheIndexabilityState::getDiscriminators(
     StringData path) const {
     PathDiscriminatorsMap::const_iterator it = _pathDiscriminatorsMap.find(path);
     if (it == _pathDiscriminatorsMap.end()) {
@@ -129,12 +90,11 @@ void PlanCacheIndexabilityState::updateDiscriminators(const std::vector<IndexEnt
 
     for (const IndexEntry& idx : indexEntries) {
         if (idx.sparse) {
-            processSparseIndex(idx.name, idx.keyPattern);
+            processSparseIndex(idx.keyPattern);
         }
         if (idx.filterExpr) {
-            processPartialIndex(idx.name, idx.filterExpr);
+            processPartialIndex(idx.filterExpr);
         }
-        processIndexCollation(idx.name, idx.keyPattern, idx.collator);
     }
 }