Update upstream source from tag 'upstream/6.0.10'debian/6.0.10-1

Update to upstream version '6.0.10'
with Debian dir 2d176fa254eee97b139f712fec5709641335a8c3

1 files changed, 49 insertions, 2 deletions

diff --git a/jstests/core/clustered_collection_collation.js b/jstests/core/clustered_collection_collation.js
index d96afb7730d..585425d6fac 100644
--- a/jstests/core/clustered_collection_collation.js
+++ b/jstests/core/clustered_collection_collation.js
@@ -35,6 +35,9 @@ const incompatibleCollation = {
     locale: "fr_CA",
     strength: 2
 };
+const simpleCollation = {
+    locale: "simple",
+};
 
 assert.commandWorked(db.createCollection(
     collatedName, {clusteredIndex: {key: {_id: 1}, unique: true}, collation: defaultCollation}));
@@ -141,7 +144,7 @@ const verifyNoTightBoundsAndFindsN = function(coll, expected, predicate, queryCo
     const max = res.queryPlanner.winningPlan.maxRecord;
     assert.neq(null, min, "No min bound");
     assert.neq(null, max, "No max bound");
-    assert.neq(min, max, "COLLSCAN bounds are equal");
+    assert(min !== max, "COLLSCAN bounds are equal");
     assert.eq(expected, coll.find(predicate).count(), "Didn't find the expected records");
 };
 
@@ -150,33 +153,77 @@ const testBounds = function(coll, expected, defaultCollation) {
     verifyHasBoundsAndFindsN(coll, 1, {_id: 5});
     verifyHasBoundsAndFindsN(coll, 1, {_id: {int: 5}});
     verifyHasBoundsAndFindsN(coll, 1, {_id: {ints: [5, 10]}});
+    verifyNoTightBoundsAndFindsN(coll, 2, {_id: {$in: [5, {ints: [5, 10]}]}});
 
     // Test non string types with incompatible collations.
     verifyHasBoundsAndFindsN(coll, 1, {_id: 5}, incompatibleCollation);
     verifyHasBoundsAndFindsN(coll, 1, {_id: {int: 5}}, incompatibleCollation);
     verifyHasBoundsAndFindsN(coll, 1, {_id: {ints: [5, 10]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, 2, {_id: {$in: [5, {ints: [5, 10]}]}}, incompatibleCollation);
 
     // Test strings respect the collation.
     verifyHasBoundsAndFindsN(coll, expected, {_id: "A"});
     verifyHasBoundsAndFindsN(coll, expected, {_id: {str: "A"}});
     verifyHasBoundsAndFindsN(coll, expected, {_id: {strs: ["A", "b"]}});
     verifyHasBoundsAndFindsN(coll, expected, {_id: {strs: ["a", "B"]}});
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", 1]}});
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", "C"]}});
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["", {str: "A"}]}});
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: [{}, {strs: ["A", "b"]}]}});
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: [[], {strs: ["a", "B"]}]}});
 
     // Test strings not in the _id field
     verifyNoBoundsAndFindsN(coll, expected, {data: ["A", "b"]});
     verifyNoBoundsAndFindsN(coll, expected, {data: ["a", "B"]});
 
-    // Test non compatible query collations don't generate bounds
+    // Test non compatible query collations don't generate exact bounds. This means, the bounds
+    // generated are with respect to the KeyString encoding of the data type of the query. For
+    // example, an _id: <string> query will be bounded by min and max values for type 'string', but
+    // not bounded by the exact value of <string>.
     verifyNoTightBoundsAndFindsN(coll, expected, {_id: "A"}, incompatibleCollation);
     verifyNoTightBoundsAndFindsN(coll, expected, {_id: {str: "A"}}, incompatibleCollation);
     verifyNoTightBoundsAndFindsN(coll, expected, {_id: {strs: ["A", "b"]}}, incompatibleCollation);
     verifyNoTightBoundsAndFindsN(coll, expected, {_id: {strs: ["a", "B"]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", 1]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", "C"]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, expected, {_id: {$in: ["", {str: "A"}]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, expected, {_id: {$in: [{}, {strs: ["A", "b"]}]}}, incompatibleCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, expected, {_id: {$in: [[], {strs: ["a", "B"]}]}}, incompatibleCollation);
+
+    if (defaultCollation != undefined && defaultCollation.locale != simpleCollation.locale) {
+        // 'Simple' collations are treated differently than non-simple queries since they are the
+        // default 'locale' when a collation is not specified. Test that the 'simple' collation is
+        // not compatible when the clustered collection has a non-simple collation.
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: "A"}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: {str: "A"}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: {strs: ["A", "b"]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: {strs: ["a", "B"]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", 1]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", "C"]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(
+            coll, expected, {_id: {$in: ["", {str: "A"}]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(
+            coll, expected, {_id: {$in: [{}, {strs: ["A", "b"]}]}}, simpleCollation);
+        verifyNoTightBoundsAndFindsN(
+            coll, expected, {_id: {$in: [[], {strs: ["a", "B"]}]}}, simpleCollation);
+    }
 
     // Test compatible query collations generate bounds
     verifyHasBoundsAndFindsN(coll, expected, {_id: "A"}, defaultCollation);
     verifyHasBoundsAndFindsN(coll, expected, {_id: {str: "A"}}, defaultCollation);
     verifyHasBoundsAndFindsN(coll, expected, {_id: {strs: ["A", "b"]}}, defaultCollation);
     verifyHasBoundsAndFindsN(coll, expected, {_id: {strs: ["a", "B"]}}, defaultCollation);
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", 1]}}, defaultCollation);
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["A", "C"]}}, defaultCollation);
+    verifyNoTightBoundsAndFindsN(coll, expected, {_id: {$in: ["", {str: "A"}]}}, defaultCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, expected, {_id: {$in: [{}, {strs: ["A", "b"]}]}}, defaultCollation);
+    verifyNoTightBoundsAndFindsN(
+        coll, expected, {_id: {$in: [[], {strs: ["a", "B"]}]}}, defaultCollation);
 };
 
 insertDocuments(collated);