SERVER-77899 remove repeat contain index from the relevant candidate indexes, this can avoid some useless calculations.

src/mongo/db/query/planner_ixselect.cpp

@@ -49,6 +49,7 @@
 #include "mongo/db/query/planner_wildcard_helpers.h"
 #include "mongo/db/query/query_planner_common.h"
 #include "mongo/logv2/log.h"
+#include "mongo/bson/simple_bsonelement_comparator.h"
 
 namespace mongo {
 
@@ -309,6 +310,103 @@ std::vector<IndexEntry> QueryPlannerIXSelect::findIndexesByHint(
     return out;
 }
 
+// remove repeat contain index from the relevant candidate indexes, this can avoid some useless calculations.
+// for example:
+//   {a:1, b:1} contain {a:1}, so we can remove index {a:1} from the candidates
+//   {a:"hashed", b:1} contain {a:"hashed"}, so we can remove index {a:"hahsed"} from the candidates
+//
+// {a:1, b:1} is better than {a:1},because both cases are satisfied for db.collection.find({a:xx}) 
+//    and db.collection.find({a:xx,b:xx})
+//
+void QueryPlannerIXSelect::removeRepeatContainIndexes(std::vector<IndexEntry>& allIndices) {
+    if (allIndices.size() <= 1)
+       return;
+
+    auto isSpecialIndex = [](auto& it) {
+        if (it->type != INDEX_BTREE && it->type != INDEX_HASHED) {
+            return true;
+        }
+
+        if (it->sparse || it->unique) {
+            return true;
+        }
+
+        if (it->collator) {
+            return true;
+        }
+
+        if (it->filterExpr) {
+            return true;
+        }
+
+        BSONElement e = it->infoObj[IndexDescriptor::kExpireAfterSecondsFieldName];
+        if (e.isNumber() == false) {
+            return false;
+        }
+
+        auto expireTime = e.number();
+        if (expireTime >= 0) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+
+    auto dealKeyPattern = [](BSONObj& indexKeyPattern) {
+        BSONObjBuilder build;
+        BSONObjIterator kpIt(indexKeyPattern);
+        while (kpIt.more()) {
+            BSONElement elt = kpIt.next();
+            if (elt.type() == mongo::String) {
+                build.append(elt.fieldName(), elt.String());
+                continue;
+            }
+
+            // The canonical check as to whether a key pattern element is "ascending" or "descending" is
+            // (elt.number() >= 0). This is defined by the Ordering class.  
+            invariant(elt.isNumber());
+            int sortOrder = (elt.number() >= 0) ? 1 : -1;
+            build.append(elt.fieldName(), sortOrder);
+        }
+
+        return build.obj();
+    };
+
+    for (auto iterator1 = allIndices.begin(); iterator1 != allIndices.end();) {
+        if (isSpecialIndex(iterator1) == true) {
+            ++iterator1;
+            continue;
+        }
+
+        BSONObj keyPattern1 = dealKeyPattern((*iterator1).keyPattern);
+
+        bool eraseIterator = false;
+        auto iterator2 = iterator1;
+        ++iterator2;
+        while (iterator2 != allIndices.end()) {
+            if (isSpecialIndex(iterator2) == true) {
+                ++iterator2;
+                continue;
+            }
+
+            BSONObj keyPattern2 = dealKeyPattern((*iterator2).keyPattern);
+
+            if (keyPattern2.isPrefixOf(keyPattern1, SimpleBSONElementComparator::kInstance)) {
+                iterator2 = allIndices.erase(iterator2);
+            } else if (keyPattern1.isPrefixOf(keyPattern2, SimpleBSONElementComparator::kInstance)) {
+                iterator1 = allIndices.erase(iterator1);
+                eraseIterator = true;
+                break;
+            } else {
+                ++iterator2;
+            }
+        }
+
+        if (eraseIterator == false)
+            iterator1++;
+    }
+}
+
 // static
 std::vector<IndexEntry> QueryPlannerIXSelect::findRelevantIndices(
     const RelevantFieldIndexMap& fields, const std::vector<IndexEntry>& allIndices) {

src/mongo/db/query/planner_ixselect.h

@@ -75,6 +75,18 @@ class QueryPlannerIXSelect {
     static std::vector<IndexEntry> findIndexesByHint(const BSONObj& hintedIndex,
                                                      const std::vector<IndexEntry>& allIndices);
 
+    /**
+     * remove repeat contain index from the relevant candidate indexes, this can avoid some useless calculations.
+     * for example:
+     *   {a:1, b:1} contain {a:1}, so we can remove index {a:1} from the candidates
+     *   {a:"hashed", b:1} contain {a:"hashed"}, so we can remove index {a:"hahsed"} from the candidates
+     *
+     * {a:1, b:1} is better than {a:1},because both cases are satisfied for db.collection.find({a:xx}) 
+     *    and db.collection.find({a:xx,b:xx})
+     */
+    static void removeRepeatContainIndexes(std::vector<IndexEntry>& indexes);
+
+
     /**
      * Finds all indices prefixed by fields we have predicates over.  Only these indices are
      * useful in answering the query.

src/mongo/db/query/query_planner.cpp

@@ -776,6 +776,17 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan(
                     "index"_attr = relevantIndices[i].toString());
     }
 
+    if (!hintedIndexEntry) {
+        QueryPlannerIXSelect::removeRepeatContainIndexes(relevantIndices);
+        for (size_t i = 0; i < relevantIndices.size(); ++i) {
+            LOGV2_DEBUG(20971,
+                        2,
+                        "After Remove Repeat Contain Btree And Hashed Index, Relevant index",
+                        "indexNumber"_attr = i,
+                        "index"_attr = relevantIndices[i].toString());
+        }
+    }
+
     // Figure out how useful each index is to each predicate.
     QueryPlannerIXSelect::rateIndices(query.root(), "", relevantIndices, query.getCollator());
     QueryPlannerIXSelect::stripInvalidAssignments(query.root(), relevantIndices);