From 0348620630f3dd86214676e7e9566a6aa6e6be5c Mon Sep 17 00:00:00 2001 From: Ted Tuckman Date: Fri, 10 Jul 2020 10:19:26 -0400 Subject: SERVER-25893 Make it easier to construct a Value from a Vector --- .../exec/add_fields_projection_executor_test.cpp | 29 ++- .../document_value/document_comparator_test.cpp | 6 +- src/mongo/db/exec/document_value/value.h | 21 +++ .../db/exec/exclusion_projection_executor_test.cpp | 78 ++++---- .../db/exec/inclusion_projection_executor_test.cpp | 198 ++++++++++----------- src/mongo/db/index/sort_key_generator_test.cpp | 53 +++--- src/mongo/db/pipeline/aggregation_request_test.cpp | 17 +- .../db/pipeline/document_path_support_test.cpp | 44 ++--- .../document_source_change_stream_test.cpp | 10 +- .../pipeline/document_source_graph_lookup_test.cpp | 3 +- src/mongo/db/pipeline/document_source_lookup.cpp | 8 +- .../db/pipeline/document_source_lookup_test.cpp | 10 +- src/mongo/db/pipeline/expression_test.cpp | 16 +- 13 files changed, 229 insertions(+), 264 deletions(-) diff --git a/src/mongo/db/exec/add_fields_projection_executor_test.cpp b/src/mongo/db/exec/add_fields_projection_executor_test.cpp index 047bbbbc42e..34c280edb29 100644 --- a/src/mongo/db/exec/add_fields_projection_executor_test.cpp +++ b/src/mongo/db/exec/add_fields_projection_executor_test.cpp @@ -450,23 +450,22 @@ TEST(AddFieldsProjectionExecutorExecutionTest, AppliesDottedAdditionToEachElemen AddFieldsProjectionExecutor addition(expCtx); addition.parse(BSON("a.b" << true)); - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; + auto result = addition.applyProjection(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}); // Adds the field "b" to every object in the array. Recurses on non-empty nested arrays. - vector expectedNestedValues = { - Value(Document{{"b", true}}), - Value(Document{{"b", true}}), - Value(Document{{"b", true}}), - Value(Document{{"b", true}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(Document{{"b", true}}), Value(Document{{"c", 1}, {"b", true}})})}; - auto result = addition.applyProjection(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto expectedResult = Document{{"a", + {Document{{"b", true}}, + Document{{"b", true}}, + Document{{"b", true}}, + Document{{"b", true}, {"c", 2}}, + vector{}, + {Document{{"b", true}}, Document{{"c", 1}, {"b", true}}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } diff --git a/src/mongo/db/exec/document_value/document_comparator_test.cpp b/src/mongo/db/exec/document_value/document_comparator_test.cpp index 548cd875fd9..c3145f7bbcc 100644 --- a/src/mongo/db/exec/document_value/document_comparator_test.cpp +++ b/src/mongo/db/exec/document_value/document_comparator_test.cpp @@ -213,9 +213,9 @@ TEST(DocumentComparatorTest, NestedObjectEqualityRespectsCollator) { TEST(DocumentComparatorTest, NestedArrayEqualityRespectsCollator) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kAlwaysEqual); - const Document doc1{{"foo", std::vector{Value("a"_sd), Value("b"_sd)}}}; - const Document doc2{{"foo", std::vector{Value("c"_sd), Value("d"_sd)}}}; - const Document doc3{{"foo", std::vector{Value("c"_sd), Value("d"_sd), Value("e"_sd)}}}; + const Document doc1{{"foo", {"a"_sd, "b"_sd}}}; + const Document doc2{{"foo", {"c"_sd, "d"_sd}}}; + const Document doc3{{"foo", {"c"_sd, "d"_sd, "e"_sd}}}; ASSERT_TRUE(DocumentComparator(&collator).evaluate(doc1 == doc2)); ASSERT_TRUE(DocumentComparator(&collator).evaluate(doc2 == doc1)); ASSERT_FALSE(DocumentComparator(&collator).evaluate(doc1 == doc3)); diff --git a/src/mongo/db/exec/document_value/value.h b/src/mongo/db/exec/document_value/value.h index 818c7dc3323..7b593780cbf 100644 --- a/src/mongo/db/exec/document_value/value.h +++ b/src/mongo/db/exec/document_value/value.h @@ -385,6 +385,16 @@ public: template ImplicitValue(T arg) : Value(std::move(arg)) {} + ImplicitValue(std::initializer_list values) : Value(convertToValues(values)) {} + + ImplicitValue(std::vector values) : Value(convertToValues(values)) {} + + static std::vector convertToValues(const std::vector& vec) { + std::vector values; + for_each(vec.begin(), vec.end(), ([&](const int& val) { values.emplace_back(val); })); + return values; + } + /** * Converts a vector of Implicit values to a single Value object. */ @@ -394,6 +404,17 @@ public: vec.begin(), vec.end(), ([&](const ImplicitValue& val) { values.push_back(val); })); return Value(values); } + + /** + * Converts a vector of Implicit values to a vector of Values. + */ + static std::vector convertToValues(const std::vector& list) { + std::vector values; + for (const ImplicitValue& val : list) { + values.push_back(val); + } + return values; + } }; } // namespace mongo diff --git a/src/mongo/db/exec/exclusion_projection_executor_test.cpp b/src/mongo/db/exec/exclusion_projection_executor_test.cpp index cdf7a305bf8..7ee6b00ccf2 100644 --- a/src/mongo/db/exec/exclusion_projection_executor_test.cpp +++ b/src/mongo/db/exec/exclusion_projection_executor_test.cpp @@ -272,22 +272,20 @@ TEST(ExclusionProjectionExecutionTest, ShouldNotCreateSubDocIfDottedExcludedFiel TEST(ExclusionProjectionExecutionTest, ShouldApplyDottedExclusionToEachElementInArray) { auto exclusion = makeExclusionProjectionWithDefaultPolicies(BSON("a.b" << false)); - std::vector nestedValues = { - Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}, {"b", 1}})})}; - std::vector expectedNestedValues = { - Value(1), - Value(Document{}), - Value(Document{}), - Value(Document{{"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; - auto result = exclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = exclusion->applyTransformation(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}, {"b", 1}}}}}}); + auto expectedResult = Document{{"a", + {1, + Document{}, + Document{}, + Document{{"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -461,18 +459,14 @@ TEST(ExclusionProjectionExecutionTest, ShouldRecurseNestedArraysByDefault) { auto exclusion = makeExclusionProjectionWithDefaultPolicies(BSON("a.b" << false)); // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [1, {c: 3}, [{c: 5}], {d: 6}]} - auto result = exclusion->applyTransformation( - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}); + auto result = exclusion->applyTransformation(Document{{"a", + {1, + Document{{"b", 2}, {"c", 3}}, + vector{Document{{"b", 4}, {"c", 5}}}, + Document{{"d", 6}}}}}); - auto expectedResult = Document{{"a", - vector{Value(1), - Value(Document{{"c", 3}}), - Value(vector{Value(Document{{"c", 5}})}), - Value(Document{{"d", 6}})}}}; + auto expectedResult = + Document{{"a", {1, Document{{"c", 3}}, vector{Document{{"c", 5}}}, Document{{"d", 6}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -482,19 +476,14 @@ TEST(ExclusionProjectionExecutionTest, ShouldNotRecurseNestedArraysForNoRecurseP // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [1, {c: 3}, [{b: 4, c: 5}], {d: // 6}]} - auto result = exclusion->applyTransformation( - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}); + auto result = exclusion->applyTransformation(Document{{"a", + {1, + Document{{"b", 2}, {"c", 3}}, + vector{Document{{"b", 4}, {"c", 5}}}, + Document{{"d", 6}}}}}); - auto expectedResult = - Document{{"a", - vector{Value(1), - Value(Document{{"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}; + auto expectedResult = Document{ + {"a", {1, Document{{"c", 3}}, vector{Document{{"b", 4}, {"c", 5}}}, Document{{"d", 6}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -503,12 +492,11 @@ TEST(ExclusionProjectionExecutionTest, ShouldNotRetainNestedArraysIfNoRecursionN auto exclusion = makeExclusionProjectionWithNoArrayRecursion(BSON("a" << false)); // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {} - const auto inputDoc = - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}; + const auto inputDoc = Document{{"a", + {1, + Document{{"b", 2}, {"c", 3}}, + vector{Document{{"b", 4}, {"c", 5}}}, + Document{{"d", 6}}}}}; auto result = exclusion->applyTransformation(inputDoc); const auto expectedResult = Document{}; diff --git a/src/mongo/db/exec/inclusion_projection_executor_test.cpp b/src/mongo/db/exec/inclusion_projection_executor_test.cpp index 2176652c437..de2464f7f11 100644 --- a/src/mongo/db/exec/inclusion_projection_executor_test.cpp +++ b/src/mongo/db/exec/inclusion_projection_executor_test.cpp @@ -549,23 +549,22 @@ TEST_F(InclusionProjectionExecutionTestWithoutFallBackToDefault, ShouldApplyDottedInclusionToEachElementInArray) { auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a.b" << true)); - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; - // Drops non-documents and non-arrays. Applies projection to documents, recurses on // nested arrays. - vector expectedNestedValues = {Value(), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}}), - Value(vector{}), - Value(vector{Value(), Value(Document{})})}; - auto result = inclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = inclusion->applyTransformation(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}); + auto expectedResult = Document{{"a", + {Value(), + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}}, + vector{}, + {Value(), Document{}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -627,22 +626,21 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a.b" << wrapInLiteral("COMPUTED"))); - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; - vector expectedNestedValues = { - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(vector{}), - Value(vector{Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}})})}; - auto result = inclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = inclusion->applyTransformation(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}); + auto expectedResult = + Document{{"a", + {Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + vector{}, + {Document{{"b", "COMPUTED"_sd}}, Document{{"b", "COMPUTED"_sd}}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -651,26 +649,26 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, auto inclusion = makeInclusionProjectionWithDefaultPolicies( BSON("a.inc" << true << "a.comp" << wrapInLiteral("COMPUTED"))); - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"inc", 1}}), - Value(Document{{"inc", 1}, {"c", 2}}), - Value(Document{{"c", 2}, {"inc", 1}}), - Value(Document{{"inc", 1}, {"c", 2}, {"comp", "original"_sd}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"inc", 1}})})}; - vector expectedNestedValues = { - Value(Document{{"comp", "COMPUTED"_sd}}), - Value(Document{{"comp", "COMPUTED"_sd}}), - Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}), - Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}), - Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}), - Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}), - Value(vector{}), - Value(vector{Value(Document{{"comp", "COMPUTED"_sd}}), - Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}})})}; - auto result = inclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = inclusion->applyTransformation( + Document{{"a", + {1, + Document{}, + Document{{"inc", 1}}, + Document{{"inc", 1}, {"c", 2}}, + Document{{"c", 2}, {"inc", 1}}, + Document{{"inc", 1}, {"c", 2}, {"comp", "original"_sd}}, + vector{}, + {1, Document{{"inc", 1}}}}}}); + auto expectedResult = Document{ + {"a", + {Document{{"comp", "COMPUTED"_sd}}, + Document{{"comp", "COMPUTED"_sd}}, + Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}, + Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}, + Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}, + Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}, + vector{}, + {Document{{"comp", "COMPUTED"_sd}}, Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -916,18 +914,12 @@ TEST_F(InclusionProjectionExecutionTestWithoutFallBackToDefault, auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a.b" << true)); // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [{b: 2}, [{b: 4}], {}]} - auto result = inclusion->applyTransformation( - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}); + auto result = inclusion->applyTransformation(Document{ + {"a", + {1, Document{{"b", 2}, {"c", 3}}, {Document{{"b", 4}, {"c", 5}}}, Document{{"d", 6}}}}}); - auto expectedResult = Document{{"a", - vector{Value(), - Value(Document{{"b", 2}}), - Value(vector{Value(Document{{"b", 4}})}), - Value(Document{})}}}; + auto expectedResult = + Document{{"a", {Value(), Document{{"b", 2}}, {Document{{"b", 4}}}, Document{}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -937,15 +929,11 @@ TEST_F(InclusionProjectionExecutionTestWithoutFallBackToDefault, auto inclusion = makeInclusionProjectionWithNoArrayRecursion(BSON("a.b" << true)); // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [{b: 2}, {}]} - auto result = inclusion->applyTransformation( - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}); + auto result = inclusion->applyTransformation(Document{ + {"a", + {1, Document{{"b", 2}, {"c", 3}}, {Document{{"b", 4}, {"c", 5}}}, Document{{"d", 6}}}}}); - auto expectedResult = Document{ - {"a", vector{Value(), Value(Document{{"b", 2}}), Value(), Value(Document{})}}}; + auto expectedResult = Document{{"a", {Value(), Document{{"b", 2}}, Value(), Document{}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -955,12 +943,9 @@ TEST_F(InclusionProjectionExecutionTestWithoutFallBackToDefault, auto inclusion = makeInclusionProjectionWithNoArrayRecursion(BSON("a" << true)); // {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => [output doc identical to input] - const auto inputDoc = - Document{{"a", - vector{Value(1), - Value(Document{{"b", 2}, {"c", 3}}), - Value(vector{Value(Document{{"b", 4}, {"c", 5}})}), - Value(Document{{"d", 6}})}}}; + const auto inputDoc = Document{ + {"a", + {1, Document{{"b", 2}, {"c", 3}}, {Document{{"b", 4}, {"c", 5}}}, Document{{"d", 6}}}}}; auto result = inclusion->applyTransformation(inputDoc); const auto& expectedResult = inputDoc; @@ -973,22 +958,21 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a.b" << wrapInLiteral("COMPUTED"))); - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; - vector expectedNestedValues = { - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(vector{}), - Value(vector{Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}})})}; - auto result = inclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = inclusion->applyTransformation(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}); + auto expectedResult = + Document{{"a", + {Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + vector{}, + {Document{{"b", "COMPUTED"_sd}}, Document{{"b", "COMPUTED"_sd}}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } @@ -1002,22 +986,20 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, // of the array and all nested arrays individually. With kDoNotRecurseNestedArrays, the // nested arrays are replaced rather than being traversed, in exactly the same way as // scalar values. - vector nestedValues = {Value(1), - Value(Document{}), - Value(Document{{"b", 1}}), - Value(Document{{"b", 1}, {"c", 2}}), - Value(vector{}), - Value(vector{Value(1), Value(Document{{"c", 1}})})}; - - vector expectedNestedValues = {Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}}), - Value(Document{{"b", "COMPUTED"_sd}})}; - - auto result = inclusion->applyTransformation(Document{{"a", nestedValues}}); - auto expectedResult = Document{{"a", expectedNestedValues}}; + auto result = inclusion->applyTransformation(Document{{"a", + {1, + Document{}, + Document{{"b", 1}}, + Document{{"b", 1}, {"c", 2}}, + vector{}, + {1, Document{{"c", 1}}}}}}); + auto expectedResult = Document{{"a", + {Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}, + Document{{"b", "COMPUTED"_sd}}}}}; ASSERT_DOCUMENT_EQ(result, expectedResult); } } // namespace diff --git a/src/mongo/db/index/sort_key_generator_test.cpp b/src/mongo/db/index/sort_key_generator_test.cpp index 17c66fe7d59..4fc3694974a 100644 --- a/src/mongo/db/index/sort_key_generator_test.cpp +++ b/src/mongo/db/index/sort_key_generator_test.cpp @@ -53,46 +53,42 @@ std::unique_ptr makeSortKeyGen(const BSONObj& sortSpec, TEST(SortKeyGeneratorTest, ExtractNumberKeyForNonCompoundSortNonNested) { auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"_id", {5}}, {"a", {5}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"_id", 5}, {"a", 5}}); ASSERT_VALUE_EQ(sortKey, Value{5}); } TEST(SortKeyGeneratorTest, ExtractNumberKeyFromDocWithSeveralFields) { auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), nullptr); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, {"z", {10}}, {"a", {6}}, {"b", {16}}}); + Document{{"_id", 0}, {"z", 10}, {"a", 6}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, Value{6}); } TEST(SortKeyGeneratorTest, ExtractStringKeyNonCompoundNonNested) { auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), nullptr); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, {"z", {"thing1"_sd}}, {"a", {"thing2"_sd}}, {"b", {16}}}); + Document{{"_id", 0}, {"z", "thing1"_sd}, {"a", "thing2"_sd}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, Value{"thing2"_sd}); } TEST(SortKeyGeneratorTest, CompoundSortPattern) { auto sortKeyGen = makeSortKeyGen(BSON("a" << 1 << "b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{ - {"_id", {0}}, {"z", {"thing1"_sd}}, {"a", {99}}, {"c", Document{{"a", {4}}}}, {"b", {16}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument( + Document{{"_id", 0}, {"z", "thing1"_sd}, {"a", 99}, {"c", Document{{"a", 4}}}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, (Value{std::vector{Value{99}, Value{16}}})); } TEST(SortKeyGeneratorTest, CompoundSortPatternWithDottedPath) { auto sortKeyGen = makeSortKeyGen(BSON("c.a" << 1 << "b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{ - {"_id", {0}}, {"z", {"thing1"_sd}}, {"a", {99}}, {"c", Document{{"a", {4}}}}, {"b", {16}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument( + Document{{"_id", 0}, {"z", "thing1"_sd}, {"a", 99}, {"c", Document{{"a", 4}}}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, (Value{std::vector{Value{4}, Value{16}}})); } TEST(SortKeyGeneratorTest, CompoundPatternLeadingFieldIsArray) { auto sortKeyGen = makeSortKeyGen(BSON("c" << 1 << "b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, - {"z", {"thing1"_sd}}, - {"a", {99}}, - {"c", Value{std::vector{Value{2}, Value{4}, Value{1}}}}, - {"b", {16}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{ + {"_id", 0}, {"z", "thing1"_sd}, {"a", 99}, {"c", std::vector{2, 4, 1}}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, (Value{std::vector{Value{1}, Value{16}}})); } @@ -100,7 +96,7 @@ TEST(SortKeyGeneratorTest, ExtractStringSortKeyWithCollatorUsesComparisonKey) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), &collator); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, {"z", {"thing1"_sd}}, {"a", {"thing2"_sd}}, {"b", {16}}}); + Document{{"_id", 0}, {"z", "thing1"_sd}, {"a", "thing2"_sd}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, Value{"2gniht"_sd}); } @@ -108,14 +104,14 @@ TEST(SortKeyGeneratorTest, CollatorHasNoEffectWhenExtractingNonStringSortKey) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), &collator); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, {"z", {10}}, {"a", {6}}, {"b", {16}}}); + Document{{"_id", 0}, {"z", 10}, {"a", 6}, {"b", 16}}); ASSERT_VALUE_EQ(sortKey, Value{6}); } TEST(SortKeyGeneratorTest, SortKeyGenerationForArraysChoosesCorrectKey) { auto sortKeyGen = makeSortKeyGen(BSON("a" << -1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{ - {"_id", {0}}, {"a", Value{std::vector{Value{1}, Value{2}, Value{3}, Value{4}}}}}); + auto sortKey = + sortKeyGen->computeSortKeyFromDocument(Document{{"_id", 0}, {"a", {1, 2, 3, 4}}}); ASSERT_VALUE_EQ(sortKey, Value{4}); } @@ -123,49 +119,48 @@ TEST(SortKeyGeneratorTest, EnsureSortKeyGenerationForArraysRespectsCollation) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); auto sortKeyGen = makeSortKeyGen(BSON("a" << 1), &collator); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"_id", {0}}, - {"a", - Value{std::vector{ - Value{"aaz"_sd}, Value{"zza"_sd}, Value{"yya"_sd}, Value{"zzb"_sd}}}}}); + Document{{"_id", {0}}, {"a", {"aaz"_sd, "zza"_sd, "yya"_sd, "zzb"_sd}}}); ASSERT_VALUE_EQ(sortKey, Value{"ayy"_sd}); } TEST(SortKeyGeneratorTest, SortKeyGenerationForArraysRespectsCompoundOrdering) { auto sortKeyGen = makeSortKeyGen(BSON("a.b" << 1 << "a.c" << -1), nullptr); auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{fromjson("{_id: 0, a: [{b: 1, c: 0}, {b: 0, c: 3}, {b: 0, c: 1}]}")}); + Document{{"_id", 0}, + {"a", + std::vector{Document{{"b", 1}, {"c", 0}}, + Document{{"b", 0}, {"c", 3}}, + Document{{"b", 0}, {"c", 1}}}}}); ASSERT_VALUE_EQ(sortKey, (Value{std::vector{Value{0}, Value{3}}})); } TEST(SortKeyGeneratorTest, SortKeyGenerationForMissingField) { auto sortKeyGen = makeSortKeyGen(BSON("b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", Value{1}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", {1}}}); ASSERT_VALUE_EQ(sortKey, Value{BSONNULL}); } TEST(SortKeyGeneratorTest, SortKeyGenerationForMissingFieldInCompoundSortPattern) { auto sortKeyGen = makeSortKeyGen(BSON("a" << 1 << "b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"b", Value{1}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"b", {1}}}); ASSERT_VALUE_EQ(sortKey, (Value{std::vector{Value{BSONNULL}, Value{1}}})); } TEST(SortKeyGeneratorTest, SortKeyGenerationForMissingFieldInEmbeddedDocument) { auto sortKeyGen = makeSortKeyGen(BSON("a.b" << 1), nullptr); - auto sortKey = - sortKeyGen->computeSortKeyFromDocument(Document{{"a", Value{Document{{"c", Value{1}}}}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", Document{{"c", 1}}}}); ASSERT_VALUE_EQ(sortKey, Value{BSONNULL}); } TEST(SortKeyGeneratorTest, SortKeyGenerationForMissingFieldInArrayElement) { auto sortKeyGen = makeSortKeyGen(BSON("a.b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument( - Document{{"a", Value{std::vector{Value{Document{}}}}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", std::vector{Document{}}}}); ASSERT_VALUE_EQ(sortKey, Value{BSONNULL}); } TEST(SortKeyGeneratorTest, SortKeyGenerationForInvalidPath) { auto sortKeyGen = makeSortKeyGen(BSON("a.b" << 1), nullptr); - auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", Value{1}}}); + auto sortKey = sortKeyGen->computeSortKeyFromDocument(Document{{"a", 1}}); ASSERT_VALUE_EQ(sortKey, Value{BSONNULL}); } diff --git a/src/mongo/db/pipeline/aggregation_request_test.cpp b/src/mongo/db/pipeline/aggregation_request_test.cpp index 8642432720f..225be1a950e 100644 --- a/src/mongo/db/pipeline/aggregation_request_test.cpp +++ b/src/mongo/db/pipeline/aggregation_request_test.cpp @@ -158,7 +158,7 @@ TEST(AggregationRequestTest, ShouldOnlySerializeRequiredFieldsIfNoOptionalFields auto expectedSerialization = Document{{AggregationRequest::kCommandName, nss.coll()}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, + {AggregationRequest::kPipelineName, std::vector{}}, {AggregationRequest::kCursorName, Value(kDefaultCursorOptionDocument)}}; ASSERT_DOCUMENT_EQ(request.serializeToCommandObj(), expectedSerialization); } @@ -181,7 +181,7 @@ TEST(AggregationRequestTest, ShouldNotSerializeOptionalValuesIfEquivalentToDefau auto expectedSerialization = Document{{AggregationRequest::kCommandName, nss.coll()}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, + {AggregationRequest::kPipelineName, std::vector{}}, {AggregationRequest::kCursorName, Value(kDefaultCursorOptionDocument)}}; ASSERT_DOCUMENT_EQ(request.serializeToCommandObj(), expectedSerialization); } @@ -216,7 +216,7 @@ TEST(AggregationRequestTest, ShouldSerializeOptionalValuesIfSet) { auto expectedSerialization = Document{{AggregationRequest::kCommandName, nss.coll()}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, + {AggregationRequest::kPipelineName, std::vector{}}, {AggregationRequest::kAllowDiskUseName, true}, {AggregationRequest::kFromMongosName, true}, {AggregationRequest::kNeedsMergeName, true}, @@ -242,7 +242,7 @@ TEST(AggregationRequestTest, ShouldSerializeBatchSizeIfSetAndExplainFalse) { auto expectedSerialization = Document{{AggregationRequest::kCommandName, nss.coll()}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, + {AggregationRequest::kPipelineName, std::vector{}}, {AggregationRequest::kCursorName, Value(Document({{AggregationRequest::kBatchSizeName, 10}}))}}; ASSERT_DOCUMENT_EQ(request.serializeToCommandObj(), expectedSerialization); @@ -254,7 +254,7 @@ TEST(AggregationRequestTest, ShouldSerialiseAggregateFieldToOneIfCollectionIsAgg auto expectedSerialization = Document{{AggregationRequest::kCommandName, 1}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, + {AggregationRequest::kPipelineName, std::vector{}}, {AggregationRequest::kCursorName, Value(Document({{AggregationRequest::kBatchSizeName, AggregationRequest::kDefaultBatchSize}}))}}; @@ -287,10 +287,9 @@ TEST(AggregationRequestTest, ShouldNotSerializeBatchSizeWhenExplainSet) { request.setBatchSize(10); request.setExplain(ExplainOptions::Verbosity::kQueryPlanner); - auto expectedSerialization = - Document{{AggregationRequest::kCommandName, nss.coll()}, - {AggregationRequest::kPipelineName, Value(std::vector{})}, - {AggregationRequest::kCursorName, Value(Document())}}; + auto expectedSerialization = Document{{AggregationRequest::kCommandName, nss.coll()}, + {AggregationRequest::kPipelineName, std::vector{}}, + {AggregationRequest::kCursorName, Value(Document())}}; ASSERT_DOCUMENT_EQ(request.serializeToCommandObj(), expectedSerialization); } diff --git a/src/mongo/db/pipeline/document_path_support_test.cpp b/src/mongo/db/pipeline/document_path_support_test.cpp index f870a317f22..5e966e08a75 100644 --- a/src/mongo/db/pipeline/document_path_support_test.cpp +++ b/src/mongo/db/pipeline/document_path_support_test.cpp @@ -70,7 +70,7 @@ TEST(VisitAllValuesAtPathTest, NestedObjectWithEmptyArrayValue) { TEST(VisitAllValuesAtPathTest, NestedObjectWithSingletonArrayValue) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", Document{{"b", vector{Value(1)}}}}}; + Document doc{{"a", Document{{"b", vector{1}}}}}; visitAllValuesAtPath(doc, FieldPath("a.b"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(1)), 1UL); @@ -79,7 +79,7 @@ TEST(VisitAllValuesAtPathTest, NestedObjectWithSingletonArrayValue) { TEST(VisitAllValuesAtPathTest, NestedObjectWithArrayValue) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", Document{{"b", vector{Value(1), Value(2), Value(3)}}}}}; + Document doc{{"a", Document{{"b", vector{1, 2, 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.b"), callback); ASSERT_EQ(values.size(), 3UL); ASSERT_EQ(values.count(Value(1)), 1UL); @@ -103,9 +103,9 @@ TEST(VisitAllValuesAtPathTest, ObjectWithArrayOfSubobjectsWithArrayValues) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; Document doc{{"a", - vector{Document{{"b", vector{Value(1), Value(2)}}}, - Document{{"b", vector{Value(2), Value(3)}}}, - Document{{"b", vector{Value(3), Value(1)}}}}}}; + vector{Document{{"b", vector{1, 2}}}, + Document{{"b", vector{2, 3}}}, + Document{{"b", vector{3, 1}}}}}}; visitAllValuesAtPath(doc, FieldPath("a.b"), callback); ASSERT_EQ(values.size(), 3UL); ASSERT_EQ(values.count(Value(1)), 1UL); @@ -151,7 +151,7 @@ TEST(VisitAllValuesAtPathTest, AcceptsNumericFieldNames) { TEST(VisitAllValuesAtPathTest, UsesNumericFieldNameToExtractElementFromArray) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", vector{Value(1), Value(Document{{"0", 1}})}}}; + Document doc{{"a", {1, Document{{"0", 1}}}}}; visitAllValuesAtPath(doc, FieldPath("a.0"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(1)), 1UL); @@ -160,10 +160,7 @@ TEST(VisitAllValuesAtPathTest, UsesNumericFieldNameToExtractElementFromArray) { TEST(VisitAllValuesAtPathTest, TreatsNegativeIndexAsFieldName) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{ - {"a", - vector{ - Value(0), Value(1), Value(Document{{"-1", "target"_sd}}), Value(Document{{"b", 3}})}}}; + Document doc{{"a", {0, 1, Document{{"-1", "target"_sd}}, Document{{"b", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.-1"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value("target"_sd)), 1UL); @@ -172,8 +169,7 @@ TEST(VisitAllValuesAtPathTest, TreatsNegativeIndexAsFieldName) { TEST(VisitAllValuesAtPathTest, ExtractsNoValuesFromOutOfBoundsIndex) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{ - {"a", vector{Value(1), Value(Document{{"b", 2}}), Value(Document{{"10", 3}})}}}; + Document doc{{"a", {1, Document{{"b", 2}}, Document{{"10", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.10"), callback); ASSERT_EQ(values.size(), 0UL); } @@ -181,10 +177,7 @@ TEST(VisitAllValuesAtPathTest, ExtractsNoValuesFromOutOfBoundsIndex) { TEST(VisitAllValuesAtPathTest, DoesNotTreatHexStringAsIndexSpecification) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", - vector{Value(1), - Value(Document{{"0x2", 2}}), - Value(Document{{"NOT THIS ONE", 3}})}}}; + Document doc{{"a", {1, Document{{"0x2", 2}}, Document{{"NOT THIS ONE", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.0x2"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(2)), 1UL); @@ -193,9 +186,7 @@ TEST(VisitAllValuesAtPathTest, DoesNotTreatHexStringAsIndexSpecification) { TEST(VisitAllValuesAtPathTest, DoesNotAcceptLeadingPlusAsArrayIndex) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", - vector{ - Value(1), Value(Document{{"+2", 2}}), Value(Document{{"NOT THIS ONE", 3}})}}}; + Document doc{{"a", {1, Document{{"+2", 2}}, Document{{"NOT THIS ONE", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.+2"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(2)), 1UL); @@ -204,10 +195,7 @@ TEST(VisitAllValuesAtPathTest, DoesNotAcceptLeadingPlusAsArrayIndex) { TEST(VisitAllValuesAtPathTest, DoesNotAcceptTrailingCharactersForArrayIndex) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", - vector{Value(1), - Value(Document{{"2xyz", 2}}), - Value(Document{{"NOT THIS ONE", 3}})}}}; + Document doc{{"a", {1, Document{{"2xyz", 2}}, Document{{"NOT THIS ONE", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.2xyz"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(2)), 1UL); @@ -216,10 +204,7 @@ TEST(VisitAllValuesAtPathTest, DoesNotAcceptTrailingCharactersForArrayIndex) { TEST(VisitAllValuesAtPathTest, DoesNotAcceptNonDigitsForArrayIndex) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", - vector{Value(1), - Value(Document{{"2x4", 2}}), - Value(Document{{"NOT THIS ONE", 3}})}}}; + Document doc{{"a", {1, Document{{"2x4", 2}}, Document{{"NOT THIS ONE", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.2x4"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(2)), 1UL); @@ -229,8 +214,7 @@ TEST(VisitAllValuesAtPathTest, DoesExtractNestedValuesFromWithinArraysTraversedWithPositionalPaths) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{ - {"a", vector{Value(1), Value(Document{{"2", 2}}), Value(Document{{"target", 3}})}}}; + Document doc{{"a", {1, Document{{"2", 2}}, Document{{"target", 3}}}}}; visitAllValuesAtPath(doc, FieldPath("a.2.target"), callback); ASSERT_EQ(values.size(), 1UL); ASSERT_EQ(values.count(Value(3)), 1UL); @@ -275,7 +259,7 @@ TEST(VisitAllValuesAtPathTest, DoesNotAddMissingValueToResults) { TEST(VisitAllValuesAtPathTest, DoesNotAddMissingValueWithinArrayToResults) { auto values = kDefaultValueComparator.makeUnorderedValueSet(); auto callback = [&values](const Value& val) { values.insert(val); }; - Document doc{{"a", vector{Value(1), Value(), Value(2)}}}; + Document doc{{"a", {1, Value(), 2}}}; visitAllValuesAtPath(doc, FieldPath("a"), callback); ASSERT_EQ(values.size(), 2UL); ASSERT_EQ(values.count(Value(1)), 1UL); diff --git a/src/mongo/db/pipeline/document_source_change_stream_test.cpp b/src/mongo/db/pipeline/document_source_change_stream_test.cpp index 678ef85676f..c4ddc661be0 100644 --- a/src/mongo/db/pipeline/document_source_change_stream_test.cpp +++ b/src/mongo/db/pipeline/document_source_change_stream_test.cpp @@ -865,13 +865,13 @@ TEST_F(ChangeStreamStageTest, TransformRemoveFields) { {DSChangeStream::kOperationTypeField, DSChangeStream::kUpdateOpType}, {DSChangeStream::kClusterTimeField, kDefaultTs}, {DSChangeStream::kNamespaceField, D{{"db", nss.db()}, {"coll", nss.coll()}}}, - {DSChangeStream::kDocumentKeyField, D{{{"_id", 1}, {"x", 2}}}}, + {DSChangeStream::kDocumentKeyField, Document{{"_id", 1}, {"x", 2}}}, { "updateDescription", - D{{"updatedFields", D{}}, {"removedFields", vector{V("y"_sd)}}}, + D{{"updatedFields", D{}}, {"removedFields", {"y"_sd}}}, }}; checkTransformation(removeField, expectedRemoveField); -} +} // namespace TEST_F(ChangeStreamStageTest, TransformReplace) { BSONObj o = BSON("_id" << 1 << "x" << 2 << "y" << 1); @@ -2014,10 +2014,10 @@ TEST_F(ChangeStreamStageDBTest, TransformRemoveFields) { {DSChangeStream::kOperationTypeField, DSChangeStream::kUpdateOpType}, {DSChangeStream::kClusterTimeField, kDefaultTs}, {DSChangeStream::kNamespaceField, D{{"db", nss.db()}, {"coll", nss.coll()}}}, - {DSChangeStream::kDocumentKeyField, D{{{"_id", 1}, {"x", 2}}}}, + {DSChangeStream::kDocumentKeyField, D{{"_id", 1}, {"x", 2}}}, { "updateDescription", - D{{"updatedFields", D{}}, {"removedFields", vector{V("y"_sd)}}}, + D{{"updatedFields", D{}}, {"removedFields", {"y"_sd}}}, }}; checkTransformation(removeField, expectedRemoveField); } diff --git a/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp b/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp index c59ed9c2ea4..3b1299ec9be 100644 --- a/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp +++ b/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp @@ -491,8 +491,7 @@ TEST_F(DocumentSourceGraphLookUpTest, ShouldExpandArraysAtEndOfConnectFromField) * \ / * `> 3 ' */ - Document startDoc{{"_id", 0}, - {"to", std::vector{Value(1), Value(2), Value(3)}}}; // Note the array. + Document startDoc{{"_id", 0}, {"to", std::vector{1, 2, 3}}}; Document middle1{{"_id", 1}, {"to", 4}}; Document middle2{{"_id", 2}, {"to", 4}}; Document middle3{{"_id", 3}, {"to", 4}}; diff --git a/src/mongo/db/pipeline/document_source_lookup.cpp b/src/mongo/db/pipeline/document_source_lookup.cpp index 94a4071d4ad..78e4d59d077 100644 --- a/src/mongo/db/pipeline/document_source_lookup.cpp +++ b/src/mongo/db/pipeline/document_source_lookup.cpp @@ -732,10 +732,10 @@ void DocumentSourceLookUp::serializeToArray( {"pipeline", pipeline}}}}; } else { doc = Document{{getSourceName(), - {Document{{"from", fromValue}, - {"as", _as.fullPath()}, - {"localField", _localField->fullPath()}, - {"foreignField", _foreignField->fullPath()}}}}}; + Document{{"from", fromValue}, + {"as", _as.fullPath()}, + {"localField", _localField->fullPath()}, + {"foreignField", _foreignField->fullPath()}}}}; } MutableDocument output(doc); diff --git a/src/mongo/db/pipeline/document_source_lookup_test.cpp b/src/mongo/db/pipeline/document_source_lookup_test.cpp index baa1fd032d0..5d8bedf72b4 100644 --- a/src/mongo/db/pipeline/document_source_lookup_test.cpp +++ b/src/mongo/db/pipeline/document_source_lookup_test.cpp @@ -726,17 +726,15 @@ TEST_F(DocumentSourceLookUpTest, ShouldPropagatePauses) { auto next = lookup->getNext(); ASSERT_TRUE(next.isAdvanced()); - ASSERT_DOCUMENT_EQ( - next.releaseDocument(), - (Document{{"foreignId", 0}, {"foreignDocs", vector{Value(Document{{"_id", 0}})}}})); + ASSERT_DOCUMENT_EQ(next.releaseDocument(), + (Document{{"foreignId", 0}, {"foreignDocs", {Document{{"_id", 0}}}}})); ASSERT_TRUE(lookup->getNext().isPaused()); next = lookup->getNext(); ASSERT_TRUE(next.isAdvanced()); - ASSERT_DOCUMENT_EQ( - next.releaseDocument(), - (Document{{"foreignId", 1}, {"foreignDocs", vector{Value(Document{{"_id", 1}})}}})); + ASSERT_DOCUMENT_EQ(next.releaseDocument(), + (Document{{"foreignId", 1}, {"foreignDocs", {Document{{"_id", 1}}}}})); ASSERT_TRUE(lookup->getNext().isPaused()); diff --git a/src/mongo/db/pipeline/expression_test.cpp b/src/mongo/db/pipeline/expression_test.cpp index e1eeb44d3d2..c5deffd22e8 100644 --- a/src/mongo/db/pipeline/expression_test.cpp +++ b/src/mongo/db/pipeline/expression_test.cpp @@ -67,7 +67,7 @@ static Value evaluateExpression(const string& expressionName, const vector& operands) { auto expCtx = ExpressionContextForTest{}; VariablesParseState vps = expCtx.variablesParseState; - const BSONObj obj = BSON(expressionName << ImplicitValue::convertToValue(operands)); + const BSONObj obj = BSON(expressionName << Value(ImplicitValue::convertToValues(operands))); auto expression = Expression::parseExpression(&expCtx, obj, vps); Value result = expression->evaluate({}, &expCtx.variables); return result; @@ -80,14 +80,14 @@ static Value evaluateExpression(const string& expressionName, */ static void assertExpectedResults( const string& expression, - initializer_list, ImplicitValue>> operations) { + initializer_list, ImplicitValue>> operations) { for (auto&& op : operations) { try { Value result = evaluateExpression(expression, op.first); ASSERT_VALUE_EQ(op.second, result); ASSERT_EQUALS(op.second.getType(), result.getType()); } catch (...) { - LOGV2(24188, "failed", "argument"_attr = ImplicitValue::convertToValue(op.first)); + LOGV2(24188, "failed", "argument"_attr = ImplicitValue::convertToValues(op.first)); throw; } } @@ -152,7 +152,7 @@ TEST(ExpressionArrayToObjectTest, KVFormatSimple) { << BSON("k" << "key2" << "v" << 3)))}, - {Value(BSON("key1" << 2 << "key2" << 3))}}}); + Value(BSON("key1" << 2 << "key2" << 3))}}); } TEST(ExpressionArrayToObjectTest, KVFormatWithDuplicates) { @@ -163,19 +163,19 @@ TEST(ExpressionArrayToObjectTest, KVFormatWithDuplicates) { << BSON("k" << "hi" << "v" << 3)))}, - {Value(BSON("hi" << 3))}}}); + Value(BSON("hi" << 3))}}); } TEST(ExpressionArrayToObjectTest, ListFormatSimple) { assertExpectedResults("$arrayToObject", {{{Value(BSON_ARRAY(BSON_ARRAY("key1" << 2) << BSON_ARRAY("key2" << 3)))}, - {Value(BSON("key1" << 2 << "key2" << 3))}}}); + Value(BSON("key1" << 2 << "key2" << 3))}}); } TEST(ExpressionArrayToObjectTest, ListFormWithDuplicates) { assertExpectedResults("$arrayToObject", {{{Value(BSON_ARRAY(BSON_ARRAY("key1" << 2) << BSON_ARRAY("key1" << 3)))}, - {Value(BSON("key1" << 3))}}}); + Value(BSON("key1" << 3))}}); } /* ------------------------ ExpressionRange --------------------------- */ @@ -2103,7 +2103,7 @@ TEST(BuiltinRemoveVariableTest, RemoveSerializesCorrectlyAfterOptimization) { namespace ExpressionMergeObjects { TEST(ExpressionMergeObjects, MergingWithSingleObjectShouldLeaveUnchanged) { - assertExpectedResults("$mergeObjects", {{{}, {Document({})}}}); + assertExpectedResults("$mergeObjects", {{{}, Document({})}}); auto doc = Document({{"a", 1}, {"b", 1}}); assertExpectedResults("$mergeObjects", {{{doc}, doc}}); -- cgit v1.2.1