diff options
Diffstat (limited to 'src/mongo/db/exec')
88 files changed, 1286 insertions, 4433 deletions
diff --git a/src/mongo/db/exec/SConscript b/src/mongo/db/exec/SConscript index fb803f2cb53..c2caf69f0f2 100644 --- a/src/mongo/db/exec/SConscript +++ b/src/mongo/db/exec/SConscript @@ -84,7 +84,6 @@ sortExecutorEnv.Library( ], LIBDEPS_PRIVATE=[ '$BUILD_DIR/mongo/db/sorter/sorter_idl', - '$BUILD_DIR/mongo/db/sorter/sorter_stats', ], ) @@ -109,7 +108,7 @@ env.Library( 'stagedebug_cmd.cpp' ], LIBDEPS=[ - "$BUILD_DIR/mongo/db/index/index_access_method", + "$BUILD_DIR/mongo/db/index/index_access_methods", "$BUILD_DIR/mongo/db/query_exec", ], LIBDEPS_PRIVATE=[ @@ -130,7 +129,6 @@ env.CppUnitTest( "find_projection_executor_test.cpp", "inclusion_projection_executor_test.cpp", "projection_executor_builder_test.cpp", - "projection_executor_redaction_test.cpp", "projection_executor_test.cpp", "projection_executor_utils_test.cpp", "projection_executor_wildcard_access_test.cpp", diff --git a/src/mongo/db/exec/add_fields_projection_executor.cpp b/src/mongo/db/exec/add_fields_projection_executor.cpp index 067059167f5..a0fd7f08580 100644 --- a/src/mongo/db/exec/add_fields_projection_executor.cpp +++ b/src/mongo/db/exec/add_fields_projection_executor.cpp @@ -93,7 +93,7 @@ private: const BSONObj& _rawObj; // Tracks which paths we've seen to ensure no two paths conflict with each other. - OrderedPathSet _seenPaths; + std::set<std::string, PathPrefixComparator> _seenPaths; }; void ProjectionSpecValidator::uassertValid(const BSONObj& spec) { diff --git a/src/mongo/db/exec/add_fields_projection_executor.h b/src/mongo/db/exec/add_fields_projection_executor.h index b1349d715d6..c2c8e8481e3 100644 --- a/src/mongo/db/exec/add_fields_projection_executor.h +++ b/src/mongo/db/exec/add_fields_projection_executor.h @@ -94,9 +94,9 @@ public: */ void parse(const BSONObj& spec); - Document serializeTransformation(boost::optional<ExplainOptions::Verbosity> explain, - const SerializationOptions& options = {}) const final { - return _root->serialize(explain, options); + Document serializeTransformation( + boost::optional<ExplainOptions::Verbosity> explain) const final { + return _root->serialize(explain); } /** @@ -112,7 +112,7 @@ public: } DocumentSource::GetModPathsReturn getModifiedPaths() const final { - OrderedPathSet computedPaths; + std::set<std::string> computedPaths; StringMap<std::string> renamedPaths; _root->reportComputedPaths(&computedPaths, &renamedPaths); return {DocumentSource::GetModPathsReturn::Type::kFiniteSet, 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 0870c53751a..007e5cc1ffb 100644 --- a/src/mongo/db/exec/add_fields_projection_executor_test.cpp +++ b/src/mongo/db/exec/add_fields_projection_executor_test.cpp @@ -685,62 +685,5 @@ TEST(AddFieldsProjectionExecutorExecutionTest, DoNotExtractComputedProjectionWit addFields.serializeTransformation(boost::none)); } -TEST(AddFieldsProjectionExecutorExecutionTest, - ExtractComputedProjectionShouldNotHideDependentSubFields) { - boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); - AddFieldsProjectionExecutor addFields(expCtx); - addFields.parse(BSON("obj" - << "$myMeta" - << "b" << BSON("$add" << BSON_ARRAY("$obj.a" << 1)))); - - const std::set<StringData> reservedNames{}; - auto [extractedAddFields, deleteFlag] = - addFields.extractComputedProjections("myMeta", "meta", reservedNames); - - ASSERT_EQ(extractedAddFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = - Document(fromjson("{obj: '$myMeta', b: {$add: ['$obj.a', {$const: 1}]}}")); - ASSERT_DOCUMENT_EQ(expectedProjection, addFields.serializeTransformation(boost::none)); -} - -TEST(AddFieldsProjectionExecutorExecutionTest, - ExtractComputedProjectionShouldNotHideDependentFieldsWithDottedSibling) { - boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); - AddFieldsProjectionExecutor addFields(expCtx); - addFields.parse(BSON("a" - << "$myMeta" - << "c.b" - << "$a.x")); - - const std::set<StringData> reservedNames{}; - auto [extractedAddFields, deleteFlag] = - addFields.extractComputedProjections("myMeta", "meta", reservedNames); - - ASSERT_EQ(extractedAddFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = Document(fromjson("{a: '$myMeta', c: {b: '$a.x'}}")); - ASSERT_DOCUMENT_EQ(expectedProjection, addFields.serializeTransformation(boost::none)); -} - -TEST(AddFieldsProjectionExecutorExecutionTest, ExtractComputedProjectionShouldNotIncludeId) { - boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); - AddFieldsProjectionExecutor addFields(expCtx); - addFields.parse(BSON("a" << BSON("$sum" << BSON_ARRAY("$myMeta" - << "$_id")))); - - const std::set<StringData> reservedNames{}; - auto [extractedAddFields, deleteFlag] = - addFields.extractComputedProjections("myMeta", "meta", reservedNames); - - ASSERT_EQ(extractedAddFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = Document(fromjson("{a: {$sum: ['$myMeta', '$_id']}}")); - ASSERT_DOCUMENT_EQ(expectedProjection, addFields.serializeTransformation(boost::none)); -} - } // namespace } // namespace mongo::projection_executor diff --git a/src/mongo/db/exec/batched_delete_stage.cpp b/src/mongo/db/exec/batched_delete_stage.cpp index fb8be63cd8a..78bfd05e352 100644 --- a/src/mongo/db/exec/batched_delete_stage.cpp +++ b/src/mongo/db/exec/batched_delete_stage.cpp @@ -242,16 +242,6 @@ PlanStage::StageState BatchedDeleteStage::_deleteBatch(WorkingSetID* out) { wuow.commit(); } catch (const WriteConflictException&) { return _prepareToRetryDrainAfterWCE(out, recordsThatNoLongerMatch); - } catch (const ExceptionFor<ErrorCodes::StaleConfig>& ex) { - if (ex->getVersionReceived() == ChunkVersion::IGNORED() && ex->getCriticalSectionSignal()) { - // If ChunkVersion is IGNORED and we encountered a critical section, then yield, wait - // for critical section to finish and then we'll resume the write from the point we had - // left. We do this to prevent large multi-writes from repeatedly failing due to - // StaleConfig and exhausting the mongos retry attempts. - planExecutorShardingCriticalSectionFuture(opCtx()) = ex->getCriticalSectionSignal(); - return _prepareToRetryDrainAfterWCE(out, recordsThatNoLongerMatch); - } - throw; } incrementSSSMetricNoOverflow(batchedDeletesSSS.docs, docsDeleted); diff --git a/src/mongo/db/exec/bucket_unpacker.cpp b/src/mongo/db/exec/bucket_unpacker.cpp index 8bba2da9e4d..bf2f1444fea 100644 --- a/src/mongo/db/exec/bucket_unpacker.cpp +++ b/src/mongo/db/exec/bucket_unpacker.cpp @@ -34,7 +34,6 @@ #include "mongo/bson/util/bsoncolumn.h" #include "mongo/db/matcher/expression.h" #include "mongo/db/matcher/expression_algo.h" -#include "mongo/db/matcher/expression_always_boolean.h" #include "mongo/db/matcher/expression_expr.h" #include "mongo/db/matcher/expression_geo.h" #include "mongo/db/matcher/expression_internal_bucket_geo_within.h" @@ -42,14 +41,9 @@ #include "mongo/db/matcher/expression_parser.h" #include "mongo/db/matcher/expression_tree.h" #include "mongo/db/matcher/extensions_callback_noop.h" -#include "mongo/db/matcher/rewrite_expr.h" #include "mongo/db/pipeline/expression.h" #include "mongo/db/timeseries/timeseries_options.h" -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -#include "mongo/logv2/log.h" - namespace mongo { using IneligiblePredicatePolicy = BucketSpec::IneligiblePredicatePolicy; @@ -64,9 +58,6 @@ bool BucketSpec::fieldIsComputed(StringData field) const { namespace { -constexpr long long max32BitEpochMillis = - static_cast<long long>(std::numeric_limits<uint32_t>::max()) * 1000; - /** * Creates an ObjectId initialized with an appropriate timestamp corresponding to 'rhs' and * returns it as a Value. @@ -86,7 +77,7 @@ auto constructObjectIdValue(const BSONElement& rhs, int bucketMaxSpanSeconds) { oid.init(date, maxOrMin == OIDInit::max); return oid; }; - // Make an ObjectId corresponding to a date value adjusted by the max bucket value for the + // Make an ObjectId cooresponding to a date value adjusted by the max bucket value for the // time series view that this query operates on. This predicate can be used in a comparison // to gauge a max value for a given bucket, rather than a min value. auto makeMaxAdjustedDateOID = [&](auto&& date, auto&& maxOrMin) { @@ -95,16 +86,9 @@ auto constructObjectIdValue(const BSONElement& rhs, int bucketMaxSpanSeconds) { // Subtract max bucket range. return makeDateOID(date - Seconds{bucketMaxSpanSeconds}, maxOrMin); else - // Since we're out of range, just make a predicate that is true for all dates. - // We'll never use an OID for a date < 0 due to OID range limitations, so we set the - // minimum date to 0. - return makeDateOID(Date_t::fromMillisSinceEpoch(0LL), OIDInit::min); + // Since we're out of range, just make a predicate that is true for all date types. + return makeDateOID(Date_t::min(), OIDInit::min); }; - - // Because the OID timestamp is only 4 bytes, we can't convert larger dates - invariant(rhs.date().toMillisSinceEpoch() >= 0LL); - invariant(rhs.date().toMillisSinceEpoch() <= max32BitEpochMillis); - // An ObjectId consists of a 4-byte timestamp, as well as a unique value and a counter, thus // two ObjectIds initialized with the same date will have different values. To ensure that we // do not incorrectly include or exclude any buckets, depending on the operator we will @@ -146,9 +130,9 @@ std::unique_ptr<MatchExpression> makeOr(std::vector<std::unique_ptr<MatchExpress return std::make_unique<OrMatchExpression>(std::move(nontrivial)); } -BucketSpec::BucketPredicate handleIneligible(IneligiblePredicatePolicy policy, - const MatchExpression* matchExpr, - StringData message) { +std::unique_ptr<MatchExpression> handleIneligible(IneligiblePredicatePolicy policy, + const MatchExpression* matchExpr, + StringData message) { switch (policy) { case IneligiblePredicatePolicy::kError: uasserted( @@ -156,7 +140,7 @@ BucketSpec::BucketPredicate handleIneligible(IneligiblePredicatePolicy policy, "Error translating non-metadata time-series predicate to operate on buckets: " + message + ": " + matchExpr->serialize().toString()); case IneligiblePredicatePolicy::kIgnore: - return {}; + return nullptr; } MONGO_UNREACHABLE_TASSERT(5916307); } @@ -220,49 +204,40 @@ std::unique_ptr<MatchExpression> createTypeEqualityPredicate( return makeOr(std::move(typeEqualityPredicates)); } -// Checks for the situations when it's not possible to create a bucket-level predicate (against the -// computed control values) for the given event-level predicate ('matchExpr'). -boost::optional<StringData> checkComparisonPredicateEligibility( +std::unique_ptr<MatchExpression> createComparisonPredicate( const ComparisonMatchExpressionBase* matchExpr, - const StringData matchExprPath, - const BSONElement& matchExprData, const BucketSpec& bucketSpec, - ExpressionContext::CollationMatchesDefault collationMatchesDefault) { + int bucketMaxSpanSeconds, + ExpressionContext::CollationMatchesDefault collationMatchesDefault, + boost::intrusive_ptr<ExpressionContext> pExpCtx, + bool haveComputedMetaField, + bool includeMetaField, + bool assumeNoMixedSchemaData, + IneligiblePredicatePolicy policy) { using namespace timeseries; + const auto matchExprPath = matchExpr->path(); + const auto matchExprData = matchExpr->getData(); + // The control field's min and max are chosen using a field-order insensitive comparator, while // MatchExpressions use a comparator that treats field-order as significant. Because of this we // will not perform this optimization on queries with operands of compound types. if (matchExprData.type() == BSONType::Object || matchExprData.type() == BSONType::Array) - return "operand can't be an object or array"_sd; + return handleIneligible(policy, matchExpr, "operand can't be an object or array"_sd); - const auto isTimeField = (matchExprPath == bucketSpec.timeField()); - - // A bucket might contain events with the missing fields. These events aren't taken in account - // when computing the control values for those fields. This design has two repercussions: - // 1. MatchExpressions have special comparison semantics regarding null, in that {$eq: null} - // will match all documents where the field is either null or missing. This semantics cannot - // be represented in terms of comparisons against the min/max control values. - // 2. Non-type-bracketing predicates, such as {$expr: {$lt(e): ['$x', 42]}} should evaluate to - // "true" if "x" is missing, which also cannot be represented as a bucket-level predicate. - // 1) time field cannot be empty. - // 2) the only type less than null is MinKey, which is internal, so we don't need to guard - // GT and GTE. - // 3) for the buckets that might have mixed schema data, we'll compare the types of min and - // max when _creating_ the bucket-level predicate (that check won't help with missing). + // MatchExpressions have special comparison semantics regarding null, in that {$eq: null} will + // match all documents where the field is either null or missing. Because this is different + // from both the comparison semantics that InternalExprComparison expressions and the control's + // min and max fields use, we will not perform this optimization on queries with null operands. if (matchExprData.type() == BSONType::jstNULL) - return "can't handle comparison to null"_sd; - if (!isTimeField && - (matchExpr->matchType() == MatchExpression::INTERNAL_EXPR_LTE || - matchExpr->matchType() == MatchExpression::INTERNAL_EXPR_LT)) { - return "can't handle a non-type-bracketing LT or LTE comparisons"_sd; - } + return handleIneligible(policy, matchExpr, "can't handle {$eq: null}"_sd); // The control field's min and max are chosen based on the collation of the collection. If the // query's collation does not match the collection's collation and the query operand is a // string or compound type (skipped above) we will not perform this optimization. if (collationMatchesDefault == ExpressionContext::CollationMatchesDefault::kNo && matchExprData.type() == BSONType::String) { - return "can't handle string comparison with a non-default collation"_sd; + return handleIneligible( + policy, matchExpr, "can't handle string comparison with a non-default collation"_sd); } // This function only handles time and measurement predicates--not metadata. @@ -277,73 +252,38 @@ boost::optional<StringData> checkComparisonPredicateEligibility( // We must avoid mapping predicates on fields computed via $addFields or a computed $project. if (bucketSpec.fieldIsComputed(matchExprPath.toString())) { - return "can't handle a computed field"_sd; - } - - // We must avoid mapping predicates on fields removed by $project. - if (!determineIncludeField(matchExprPath, bucketSpec.behavior(), bucketSpec.fieldSet())) { - return "can't handle a field removed by projection"_sd; + return handleIneligible(policy, matchExpr, "can't handle a computed field"); } + const auto isTimeField = (matchExprPath == bucketSpec.timeField()); if (isTimeField && matchExprData.type() != BSONType::Date) { - // TODO SERVER-84207: right now we will end up unpacking everything and applying the event - // filter, which indeed would be either trivially true or trivially false but it won't be - // optimized away. - return "can't handle comparison of time field to a non-Date type"_sd; + // Users are not allowed to insert non-date measurements into time field. So this query + // would not match anything. We do not need to optimize for this case. + return handleIneligible( + policy, + matchExpr, + "This predicate will never be true, because the time field always contains a Date"); } - return boost::none; -} - -std::unique_ptr<MatchExpression> createComparisonPredicate( - const ComparisonMatchExpressionBase* matchExpr, - const BucketSpec& bucketSpec, - int bucketMaxSpanSeconds, - ExpressionContext::CollationMatchesDefault collationMatchesDefault, - boost::intrusive_ptr<ExpressionContext> pExpCtx, - bool haveComputedMetaField, - bool includeMetaField, - bool assumeNoMixedSchemaData, - IneligiblePredicatePolicy policy) { - using namespace timeseries; - const auto matchExprPath = matchExpr->path(); - const auto matchExprData = matchExpr->getData(); - - const auto error = checkComparisonPredicateEligibility( - matchExpr, matchExprPath, matchExprData, bucketSpec, collationMatchesDefault); - if (error) { - return handleIneligible(policy, matchExpr, *error).loosePredicate; - } - - const auto isTimeField = (matchExprPath == bucketSpec.timeField()); - auto minPath = std::string{kControlMinFieldNamePrefix} + matchExprPath; - const StringData minPathStringData(minPath); - auto maxPath = std::string{kControlMaxFieldNamePrefix} + matchExprPath; - const StringData maxPathStringData(maxPath); - BSONObj minTime; BSONObj maxTime; - bool dateIsExtended = false; if (isTimeField) { auto timeField = matchExprData.Date(); minTime = BSON("" << timeField - Seconds(bucketMaxSpanSeconds)); maxTime = BSON("" << timeField + Seconds(bucketMaxSpanSeconds)); - - // The date is in the "extended" range if it doesn't fit into the bottom - // 32 bits. - long long timestamp = timeField.toMillisSinceEpoch(); - dateIsExtended = timestamp < 0LL || timestamp > max32BitEpochMillis; } + auto minPath = std::string{kControlMinFieldNamePrefix} + matchExprPath; + auto maxPath = std::string{kControlMaxFieldNamePrefix} + matchExprPath; + switch (matchExpr->matchType()) { case MatchExpression::EQ: case MatchExpression::INTERNAL_EXPR_EQ: // For $eq, make both a $lte against 'control.min' and a $gte predicate against // 'control.max'. // - // If the comparison is against the 'time' field and we haven't stored a time outside of - // the 32 bit range, include a predicate against the _id field which is converted to - // the maximum for the corresponding range of ObjectIds and + // If the comparison is against the 'time' field, include a predicate against the _id + // field which is converted to the maximum for the corresponding range of ObjectIds and // is adjusted by the max range for a bucket to approximate the max bucket value given // the min. Also include a predicate against the _id field which is converted to the // minimum for the range of ObjectIds corresponding to the given date. In @@ -353,91 +293,60 @@ std::unique_ptr<MatchExpression> createComparisonPredicate( // // The same procedure applies to aggregation expressions of the form // {$expr: {$eq: [...]}} that can be rewritten to use $_internalExprEq. - if (!isTimeField) { - return makeOr(makeVector<std::unique_ptr<MatchExpression>>( - makePredicate( - MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData)), - createTypeEqualityPredicate(pExpCtx, matchExprPath, assumeNoMixedSchemaData))); - } else if (bucketSpec.usesExtendedRange()) { - return makePredicate( - MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, - minTime.firstElement()), - MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, - maxTime.firstElement())); - } else if (dateIsExtended) { - // Since by this point we know that no time value has been inserted which is - // outside the epoch range, we know that no document can meet this criteria - return std::make_unique<AlwaysFalseMatchExpression>(); - } else { - return makePredicate( - MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, - minTime.firstElement()), - MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, - maxTime.firstElement()), - MatchExprPredicate<LTEMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<LTEMatchExpression>(matchExprData, - bucketMaxSpanSeconds)), - MatchExprPredicate<GTEMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<GTEMatchExpression>(matchExprData, - bucketMaxSpanSeconds))); - } - MONGO_UNREACHABLE_TASSERT(6646903); + return isTimeField + ? makePredicate( + MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), + MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, + minTime.firstElement()), + MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), + MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, + maxTime.firstElement()), + MatchExprPredicate<LTEMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<LTEMatchExpression>(matchExprData, + bucketMaxSpanSeconds)), + MatchExprPredicate<GTEMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<GTEMatchExpression>(matchExprData, + bucketMaxSpanSeconds))) + : makeOr(makeVector<std::unique_ptr<MatchExpression>>( + makePredicate(MatchExprPredicate<InternalExprLTEMatchExpression>( + minPath, matchExprData), + MatchExprPredicate<InternalExprGTEMatchExpression>( + maxPath, matchExprData)), + createTypeEqualityPredicate( + pExpCtx, matchExprPath, assumeNoMixedSchemaData))); case MatchExpression::GT: case MatchExpression::INTERNAL_EXPR_GT: // For $gt, make a $gt predicate against 'control.max'. In addition, if the comparison - // is against the 'time' field, and the collection doesn't contain times outside the - // 32 bit range, include a predicate against the _id field which is converted to the - // maximum for the corresponding range of ObjectIds and is adjusted by the max range - // for a bucket to approximate the max bucket value given the min. - // - // In addition, we include a {'control.min' : {$gt: 'time - bucketMaxSpanSeconds'}} + // is against the 'time' field, include a predicate against the _id field which is + // converted to the maximum for the corresponding range of ObjectIds and is adjusted + // by the max range for a bucket to approximate the max bucket value given the min. In + // addition, we include a {'control.min' : {$gt: 'time - bucketMaxSpanSeconds'}} // predicate which will be helpful in reducing bounds for index scans on 'time' field // and routing on mongos. // // The same procedure applies to aggregation expressions of the form // {$expr: {$gt: [...]}} that can be rewritten to use $_internalExprGt. - if (!isTimeField) { - return makeOr(makeVector<std::unique_ptr<MatchExpression>>( - std::make_unique<InternalExprGTMatchExpression>(maxPath, matchExprData), - createTypeEqualityPredicate(pExpCtx, matchExprPath, assumeNoMixedSchemaData))); - } else if (bucketSpec.usesExtendedRange()) { - return makePredicate( - MatchExprPredicate<InternalExprGTMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprGTMatchExpression>(minPath, - minTime.firstElement())); - } else if (matchExprData.Date().toMillisSinceEpoch() < 0LL) { - // Since by this point we know that no time value has been inserted < 0, - // every document must meet this criteria - return std::make_unique<AlwaysTrueMatchExpression>(); - } else if (matchExprData.Date().toMillisSinceEpoch() > max32BitEpochMillis) { - // Since by this point we know that no time value has been inserted > - // max32BitEpochMillis, we know that no document can meet this criteria - return std::make_unique<AlwaysFalseMatchExpression>(); - } else { - return makePredicate( - MatchExprPredicate<InternalExprGTMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprGTMatchExpression>(minPath, - minTime.firstElement()), - MatchExprPredicate<GTMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<GTMatchExpression>(matchExprData, - bucketMaxSpanSeconds))); - } - MONGO_UNREACHABLE_TASSERT(6646904); + return isTimeField + ? makePredicate( + MatchExprPredicate<InternalExprGTMatchExpression>(maxPath, matchExprData), + MatchExprPredicate<InternalExprGTMatchExpression>(minPath, + minTime.firstElement()), + MatchExprPredicate<GTMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<GTMatchExpression>(matchExprData, + bucketMaxSpanSeconds))) + : makeOr(makeVector<std::unique_ptr<MatchExpression>>( + std::make_unique<InternalExprGTMatchExpression>(maxPath, matchExprData), + createTypeEqualityPredicate( + pExpCtx, matchExprPath, assumeNoMixedSchemaData))); case MatchExpression::GTE: case MatchExpression::INTERNAL_EXPR_GTE: // For $gte, make a $gte predicate against 'control.max'. In addition, if the comparison - // is against the 'time' field, and the collection doesn't contain times outside the - // 32 bit range, include a predicate against the _id field which is + // is against the 'time' field, include a predicate against the _id field which is // converted to the minimum for the corresponding range of ObjectIds and is adjusted // by the max range for a bucket to approximate the max bucket value given the min. In // addition, we include a {'control.min' : {$gte: 'time - bucketMaxSpanSeconds'}} @@ -446,83 +355,49 @@ std::unique_ptr<MatchExpression> createComparisonPredicate( // // The same procedure applies to aggregation expressions of the form // {$expr: {$gte: [...]}} that can be rewritten to use $_internalExprGte. - if (!isTimeField) { - return makeOr(makeVector<std::unique_ptr<MatchExpression>>( - std::make_unique<InternalExprGTEMatchExpression>(maxPath, matchExprData), - createTypeEqualityPredicate(pExpCtx, matchExprPath, assumeNoMixedSchemaData))); - } else if (bucketSpec.usesExtendedRange()) { - return makePredicate( - MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, - minTime.firstElement())); - } else if (matchExprData.Date().toMillisSinceEpoch() < 0LL) { - // Since by this point we know that no time value has been inserted < 0, - // every document must meet this criteria - return std::make_unique<AlwaysTrueMatchExpression>(); - } else if (matchExprData.Date().toMillisSinceEpoch() > max32BitEpochMillis) { - // Since by this point we know that no time value has been inserted > 0xffffffff, - // we know that no value can meet this criteria - return std::make_unique<AlwaysFalseMatchExpression>(); - } else { - return makePredicate( - MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), - MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, - minTime.firstElement()), - MatchExprPredicate<GTEMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<GTEMatchExpression>(matchExprData, - bucketMaxSpanSeconds))); - } - MONGO_UNREACHABLE_TASSERT(6646905); + return isTimeField + ? makePredicate( + MatchExprPredicate<InternalExprGTEMatchExpression>(maxPath, matchExprData), + MatchExprPredicate<InternalExprGTEMatchExpression>(minPath, + minTime.firstElement()), + MatchExprPredicate<GTEMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<GTEMatchExpression>(matchExprData, + bucketMaxSpanSeconds))) + : makeOr(makeVector<std::unique_ptr<MatchExpression>>( + std::make_unique<InternalExprGTEMatchExpression>(maxPath, matchExprData), + createTypeEqualityPredicate( + pExpCtx, matchExprPath, assumeNoMixedSchemaData))); case MatchExpression::LT: case MatchExpression::INTERNAL_EXPR_LT: // For $lt, make a $lt predicate against 'control.min'. In addition, if the comparison // is against the 'time' field, include a predicate against the _id field which is - // converted to the minimum for the corresponding range of ObjectIds, unless the - // collection contain extended range dates which won't fit int the 32 bits allocated - // for _id. - // - // In addition, we include a {'control.max' : {$lt: 'time + bucketMaxSpanSeconds'}} + // converted to the minimum for the corresponding range of ObjectIds. In + // addition, we include a {'control.max' : {$lt: 'time + bucketMaxSpanSeconds'}} // predicate which will be helpful in reducing bounds for index scans on 'time' field // and routing on mongos. // // The same procedure applies to aggregation expressions of the form // {$expr: {$lt: [...]}} that can be rewritten to use $_internalExprLt. - if (!isTimeField) { - return makeOr(makeVector<std::unique_ptr<MatchExpression>>( - std::make_unique<InternalExprLTMatchExpression>(minPath, matchExprData), - createTypeEqualityPredicate(pExpCtx, matchExprPath, assumeNoMixedSchemaData))); - } else if (bucketSpec.usesExtendedRange()) { - return makePredicate( - MatchExprPredicate<InternalExprLTMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprLTMatchExpression>(maxPath, - maxTime.firstElement())); - } else if (matchExprData.Date().toMillisSinceEpoch() < 0LL) { - // Since by this point we know that no time value has been inserted < 0, - // we know that no document can meet this criteria - return std::make_unique<AlwaysFalseMatchExpression>(); - } else if (matchExprData.Date().toMillisSinceEpoch() > max32BitEpochMillis) { - // Since by this point we know that no time value has been inserted > 0xffffffff - // every time value must be less than this value - return std::make_unique<AlwaysTrueMatchExpression>(); - } else { - return makePredicate( - MatchExprPredicate<InternalExprLTMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprLTMatchExpression>(maxPath, - maxTime.firstElement()), - MatchExprPredicate<LTMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<LTMatchExpression>(matchExprData, - bucketMaxSpanSeconds))); - } - MONGO_UNREACHABLE_TASSERT(6646906); + return isTimeField + ? makePredicate( + MatchExprPredicate<InternalExprLTMatchExpression>(minPath, matchExprData), + MatchExprPredicate<InternalExprLTMatchExpression>(maxPath, + maxTime.firstElement()), + MatchExprPredicate<LTMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<LTMatchExpression>(matchExprData, + bucketMaxSpanSeconds))) + : makeOr(makeVector<std::unique_ptr<MatchExpression>>( + std::make_unique<InternalExprLTMatchExpression>(minPath, matchExprData), + createTypeEqualityPredicate( + pExpCtx, matchExprPath, assumeNoMixedSchemaData))); case MatchExpression::LTE: case MatchExpression::INTERNAL_EXPR_LTE: // For $lte, make a $lte predicate against 'control.min'. In addition, if the comparison - // is against the 'time' field, and the collection doesn't contain times outside the - // 32 bit range, include a predicate against the _id field which is + // is against the 'time' field, include a predicate against the _id field which is // converted to the maximum for the corresponding range of ObjectIds. In // addition, we include a {'control.max' : {$lte: 'time + bucketMaxSpanSeconds'}} // predicate which will be helpful in reducing bounds for index scans on 'time' field @@ -530,34 +405,19 @@ std::unique_ptr<MatchExpression> createComparisonPredicate( // // The same procedure applies to aggregation expressions of the form // {$expr: {$lte: [...]}} that can be rewritten to use $_internalExprLte. - if (!isTimeField) { - return makeOr(makeVector<std::unique_ptr<MatchExpression>>( - std::make_unique<InternalExprLTEMatchExpression>(minPath, matchExprData), - createTypeEqualityPredicate(pExpCtx, matchExprPath, assumeNoMixedSchemaData))); - } else if (bucketSpec.usesExtendedRange()) { - return makePredicate( - MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, - maxTime.firstElement())); - } else if (matchExprData.Date().toMillisSinceEpoch() < 0LL) { - // Since by this point we know that no time value has been inserted < 0, - // we know that no document can meet this criteria - return std::make_unique<AlwaysFalseMatchExpression>(); - } else if (matchExprData.Date().toMillisSinceEpoch() > max32BitEpochMillis) { - // Since by this point we know that no time value has been inserted > 0xffffffff - // every document must be less than this value - return std::make_unique<AlwaysTrueMatchExpression>(); - } else { - return makePredicate( - MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), - MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, - maxTime.firstElement()), - MatchExprPredicate<LTEMatchExpression, Value>( - kBucketIdFieldName, - constructObjectIdValue<LTEMatchExpression>(matchExprData, - bucketMaxSpanSeconds))); - } - MONGO_UNREACHABLE_TASSERT(6646907); + return isTimeField + ? makePredicate( + MatchExprPredicate<InternalExprLTEMatchExpression>(minPath, matchExprData), + MatchExprPredicate<InternalExprLTEMatchExpression>(maxPath, + maxTime.firstElement()), + MatchExprPredicate<LTEMatchExpression, Value>( + kBucketIdFieldName, + constructObjectIdValue<LTEMatchExpression>(matchExprData, + bucketMaxSpanSeconds))) + : makeOr(makeVector<std::unique_ptr<MatchExpression>>( + std::make_unique<InternalExprLTEMatchExpression>(minPath, matchExprData), + createTypeEqualityPredicate( + pExpCtx, matchExprPath, assumeNoMixedSchemaData))); default: MONGO_UNREACHABLE_TASSERT(5348302); @@ -566,119 +426,9 @@ std::unique_ptr<MatchExpression> createComparisonPredicate( MONGO_UNREACHABLE_TASSERT(5348303); } -std::unique_ptr<MatchExpression> createTightComparisonPredicate( - const ComparisonMatchExpressionBase* matchExpr, - const BucketSpec& bucketSpec, - ExpressionContext::CollationMatchesDefault collationMatchesDefault) { - using namespace timeseries; - const auto matchExprPath = matchExpr->path(); - const auto matchExprData = matchExpr->getData(); - - const auto error = checkComparisonPredicateEligibility( - matchExpr, matchExprPath, matchExprData, bucketSpec, collationMatchesDefault); - if (error) { - return handleIneligible(BucketSpec::IneligiblePredicatePolicy::kIgnore, matchExpr, *error) - .loosePredicate; - } - - // We have to disable the tight predicate for the measurement field. There might be missing - // values in the measurements and the control fields ignore them on insertion. So we cannot use - // bucket min and max to determine the property of all events in the bucket. For measurement - // fields, there's a further problem that if the control field is an array, we cannot generate - // the tight predicate because the predicate will be implicitly mapped over the array elements. - if (matchExprPath != bucketSpec.timeField()) { - return handleIneligible(BucketSpec::IneligiblePredicatePolicy::kIgnore, - matchExpr, - "can't create tight predicate on non-time field") - .tightPredicate; - } - - auto minPath = std::string{kControlMinFieldNamePrefix} + matchExprPath; - const StringData minPathStringData(minPath); - auto maxPath = std::string{kControlMaxFieldNamePrefix} + matchExprPath; - const StringData maxPathStringData(maxPath); - - switch (matchExpr->matchType()) { - // All events satisfy $eq if bucket min and max both satisfy $eq. - case MatchExpression::EQ: - return makePredicate( - MatchExprPredicate<EqualityMatchExpression>(minPathStringData, matchExprData), - MatchExprPredicate<EqualityMatchExpression>(maxPathStringData, matchExprData)); - case MatchExpression::INTERNAL_EXPR_EQ: - return makePredicate( - MatchExprPredicate<InternalExprEqMatchExpression>(minPathStringData, matchExprData), - MatchExprPredicate<InternalExprEqMatchExpression>(maxPathStringData, - matchExprData)); - - // All events satisfy $gt if bucket min satisfy $gt. - case MatchExpression::GT: - return std::make_unique<GTMatchExpression>(minPathStringData, matchExprData); - case MatchExpression::INTERNAL_EXPR_GT: - return std::make_unique<InternalExprGTMatchExpression>(minPathStringData, - matchExprData); - - // All events satisfy $gte if bucket min satisfy $gte. - case MatchExpression::GTE: - return std::make_unique<GTEMatchExpression>(minPathStringData, matchExprData); - case MatchExpression::INTERNAL_EXPR_GTE: - return std::make_unique<InternalExprGTEMatchExpression>(minPathStringData, - matchExprData); - - // All events satisfy $lt if bucket max satisfy $lt. - case MatchExpression::LT: - return std::make_unique<LTMatchExpression>(maxPathStringData, matchExprData); - case MatchExpression::INTERNAL_EXPR_LT: - return std::make_unique<InternalExprLTMatchExpression>(maxPathStringData, - matchExprData); - - // All events satisfy $lte if bucket max satisfy $lte. - case MatchExpression::LTE: - return std::make_unique<LTEMatchExpression>(maxPathStringData, matchExprData); - case MatchExpression::INTERNAL_EXPR_LTE: - return std::make_unique<InternalExprLTEMatchExpression>(maxPathStringData, - matchExprData); - - default: - MONGO_UNREACHABLE_TASSERT(7026901); - } -} - -std::unique_ptr<MatchExpression> createTightExprTimeFieldPredicate( - const ExprMatchExpression* matchExpr, - const BucketSpec& bucketSpec, - ExpressionContext::CollationMatchesDefault collationMatchesDefault, - boost::intrusive_ptr<ExpressionContext> pExpCtx) { - using namespace timeseries; - RewriteExpr::RewriteResult rewriteRes = - RewriteExpr::rewrite(matchExpr->getExpression(), pExpCtx->getCollator()); - auto unownedExpr = rewriteRes.matchExpression(); - - // There might be children in the $and expression that cannot be rewritten to a match - // expression. If this is the case we cannot assume that the tight predicate or - // wholeBucketFilter produced by the rewritten $and expression is correct. Measurements in the - // bucket might fit the rewritten $and expression, but fail to fit the other children of the - // $and expression and will be returned incorrectly. - - // It is an error to call 'createPredicate' on predicates on the meta field, and it only - // returns a value for predicates on the 'timeField'. - if (unownedExpr && rewriteRes.allSubExpressionsRewritten() && - unownedExpr->path() == bucketSpec.timeField() && - ComparisonMatchExpressionBase::isInternalExprComparison(unownedExpr->matchType())) { - const auto compareMatchExpr = - checked_cast<const ComparisonMatchExpressionBase*>(unownedExpr); - return createTightComparisonPredicate( - compareMatchExpr, bucketSpec, collationMatchesDefault); - } - - return handleIneligible(BucketSpec::IneligiblePredicatePolicy::kIgnore, - matchExpr, - "can only handle comparison $expr match expressions on the timeField") - .tightPredicate; -} - } // namespace -BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( +std::unique_ptr<MatchExpression> BucketSpec::createPredicatesOnBucketLevelField( const MatchExpression* matchExpr, const BucketSpec& bucketSpec, int bucketMaxSpanSeconds, @@ -693,8 +443,7 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( // If we have a leaf predicate on a meta field, we can map it to the bucket's meta field. // This includes comparisons such as $eq and $lte, as well as other non-comparison predicates - // such as $exists, or $mod. Unrenamable expressions can't be split into a whole bucket level - // filter, when we should return nullptr. + // such as $exists, $mod, or $elemMatch. // // Metadata predicates are partially handled earlier, by splitting the match expression into a // metadata-only part, and measurement/time-only part. However, splitting a $match into two @@ -712,65 +461,39 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( if (!includeMetaField) return handleIneligible(policy, matchExpr, "cannot handle an excluded meta field"); - if (expression::hasOnlyRenameableMatchExpressionChildren(*matchExpr)) { - auto looseResult = matchExpr->shallowClone(); - expression::applyRenamesToExpression( - looseResult.get(), - {{bucketSpec.metaField().value(), timeseries::kBucketMetaFieldName.toString()}}); - auto tightResult = looseResult->shallowClone(); - return {std::move(looseResult), std::move(tightResult)}; - } else { - return {nullptr, nullptr}; - } + auto result = matchExpr->shallowClone(); + expression::applyRenamesToExpression( + result.get(), + {{bucketSpec.metaField().get(), timeseries::kBucketMetaFieldName.toString()}}); + return result; } if (matchExpr->matchType() == MatchExpression::AND) { auto nextAnd = static_cast<const AndMatchExpression*>(matchExpr); - auto looseAndExpression = std::make_unique<AndMatchExpression>(); - auto tightAndExpression = std::make_unique<AndMatchExpression>(); - for (size_t i = 0; i < nextAnd->numChildren(); i++) { - auto child = createPredicatesOnBucketLevelField(nextAnd->getChild(i), - bucketSpec, - bucketMaxSpanSeconds, - collationMatchesDefault, - pExpCtx, - haveComputedMetaField, - includeMetaField, - assumeNoMixedSchemaData, - policy); - if (child.loosePredicate) { - looseAndExpression->add(std::move(child.loosePredicate)); - } + auto andMatchExpr = std::make_unique<AndMatchExpression>(); - if (tightAndExpression && child.tightPredicate) { - tightAndExpression->add(std::move(child.tightPredicate)); - } else { - // For tight expression, null means always false, we can short circuit here. - tightAndExpression = nullptr; + for (size_t i = 0; i < nextAnd->numChildren(); i++) { + if (auto child = createPredicatesOnBucketLevelField(nextAnd->getChild(i), + bucketSpec, + bucketMaxSpanSeconds, + collationMatchesDefault, + pExpCtx, + haveComputedMetaField, + includeMetaField, + assumeNoMixedSchemaData, + policy)) { + andMatchExpr->add(std::move(child)); } } - - // For a loose predicate, if we are unable to generate an expression we can just treat it as - // always true or an empty AND. This is because we are trying to generate a predicate that - // will match the superset of our actual results. - std::unique_ptr<MatchExpression> looseExpression = nullptr; - if (looseAndExpression->numChildren() == 1) { - looseExpression = looseAndExpression->releaseChild(0); - } else if (looseAndExpression->numChildren() > 1) { - looseExpression = std::move(looseAndExpression); + if (andMatchExpr->numChildren() == 1) { + return andMatchExpr->releaseChild(0); } - - // For a tight predicate, if we are unable to generate an expression we can just treat it as - // always false. This is because we are trying to generate a predicate that will match the - // subset of our actual results. - std::unique_ptr<MatchExpression> tightExpression = nullptr; - if (tightAndExpression && tightAndExpression->numChildren() == 1) { - tightExpression = tightAndExpression->releaseChild(0); - } else { - tightExpression = std::move(tightAndExpression); + if (andMatchExpr->numChildren() > 0) { + return andMatchExpr; } - return {std::move(looseExpression), std::move(tightExpression)}; + // No error message here: an empty AND is valid. + return nullptr; } else if (matchExpr->matchType() == MatchExpression::OR) { // Given {$or: [A, B]}, suppose A, B can be pushed down as A', B'. // If an event matches {$or: [A, B]} then either: @@ -778,9 +501,9 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( // - it matches B, which means any bucket containing it matches B' // So {$or: [A', B']} will capture all the buckets we need to satisfy {$or: [A, B]}. auto nextOr = static_cast<const OrMatchExpression*>(matchExpr); - auto looseOrExpression = std::make_unique<OrMatchExpression>(); - auto tightOrExpression = std::make_unique<OrMatchExpression>(); + auto result = std::make_unique<OrMatchExpression>(); + bool alwaysTrue = false; for (size_t i = 0; i < nextOr->numChildren(); i++) { auto child = createPredicatesOnBucketLevelField(nextOr->getChild(i), bucketSpec, @@ -791,86 +514,51 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( includeMetaField, assumeNoMixedSchemaData, policy); - if (looseOrExpression && child.loosePredicate) { - looseOrExpression->add(std::move(child.loosePredicate)); + if (child) { + result->add(std::move(child)); } else { - // For loose expression, null means always true, we can short circuit here. - looseOrExpression = nullptr; - } + // Since this argument is always-true, the entire OR is always-true. + alwaysTrue = true; - // For tight predicate, we give a tighter bound so that all events in the bucket - // either all matches A or all matches B. - if (child.tightPredicate) { - tightOrExpression->add(std::move(child.tightPredicate)); + // Only short circuit if we're uninterested in reporting errors. + if (policy == IneligiblePredicatePolicy::kIgnore) + break; } } + if (alwaysTrue) + return nullptr; - // For a loose predicate, if we are unable to generate an expression we can just treat it as - // always true. This is because we are trying to generate a predicate that will match the - // superset of our actual results. - std::unique_ptr<MatchExpression> looseExpression = nullptr; - if (looseOrExpression && looseOrExpression->numChildren() == 1) { - looseExpression = looseOrExpression->releaseChild(0); - } else { - looseExpression = std::move(looseOrExpression); - } - - // For a tight predicate, if we are unable to generate an expression we can just treat it as - // always false or an empty OR. This is because we are trying to generate a predicate that - // will match the subset of our actual results. - std::unique_ptr<MatchExpression> tightExpression = nullptr; - if (tightOrExpression->numChildren() == 1) { - tightExpression = tightOrExpression->releaseChild(0); - } else if (tightOrExpression->numChildren() > 1) { - tightExpression = std::move(tightOrExpression); - } - - return {std::move(looseExpression), std::move(tightExpression)}; + // No special case for an empty OR: returning nullptr would be incorrect because it + // means 'always-true', here. + return result; } else if (ComparisonMatchExpression::isComparisonMatchExpression(matchExpr) || ComparisonMatchExpressionBase::isInternalExprComparison(matchExpr->matchType())) { - return { - createComparisonPredicate(checked_cast<const ComparisonMatchExpressionBase*>(matchExpr), - bucketSpec, - bucketMaxSpanSeconds, - collationMatchesDefault, - pExpCtx, - haveComputedMetaField, - includeMetaField, - assumeNoMixedSchemaData, - policy), - createTightComparisonPredicate( - checked_cast<const ComparisonMatchExpressionBase*>(matchExpr), - bucketSpec, - collationMatchesDefault)}; - } else if (matchExpr->matchType() == MatchExpression::EXPRESSION) { - return { - // The loose predicate will be pushed before the unpacking which will be inspected by - // the - // query planner. Since the classic planner doesn't handle the $expr expression, we - // don't - // generate the loose predicate. - nullptr, - createTightExprTimeFieldPredicate(checked_cast<const ExprMatchExpression*>(matchExpr), - bucketSpec, - collationMatchesDefault, - pExpCtx)}; + return createComparisonPredicate( + checked_cast<const ComparisonMatchExpressionBase*>(matchExpr), + bucketSpec, + bucketMaxSpanSeconds, + collationMatchesDefault, + pExpCtx, + haveComputedMetaField, + includeMetaField, + assumeNoMixedSchemaData, + policy); } else if (matchExpr->matchType() == MatchExpression::GEO) { auto& geoExpr = static_cast<const GeoMatchExpression*>(matchExpr)->getGeoExpression(); if (geoExpr.getPred() == GeoExpression::WITHIN || geoExpr.getPred() == GeoExpression::INTERSECT) { - return {std::make_unique<InternalBucketGeoWithinMatchExpression>( - geoExpr.getGeometryPtr(), geoExpr.getField()), - nullptr}; + return std::make_unique<InternalBucketGeoWithinMatchExpression>( + geoExpr.getGeometryPtr(), geoExpr.getField()); } } else if (matchExpr->matchType() == MatchExpression::EXISTS) { if (assumeNoMixedSchemaData) { // We know that every field that appears in an event will also appear in the min/max. auto result = std::make_unique<AndMatchExpression>(); - result->add(std::make_unique<ExistsMatchExpression>(StringData( - std::string{timeseries::kControlMinFieldNamePrefix} + matchExpr->path()))); - result->add(std::make_unique<ExistsMatchExpression>(StringData( - std::string{timeseries::kControlMaxFieldNamePrefix} + matchExpr->path()))); - return {std::move(result), nullptr}; + result->add(std::make_unique<ExistsMatchExpression>( + std::string{timeseries::kControlMinFieldNamePrefix} + matchExpr->path())); + result->add(std::make_unique<ExistsMatchExpression>( + std::string{timeseries::kControlMaxFieldNamePrefix} + matchExpr->path())); + return result; } else { // At time of writing, we only pass 'kError' when creating a partial index, and // we know the collection will have no mixed-schema buckets by the time the index is @@ -879,7 +567,7 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( "Can't push down {$exists: true} when the collection may have mixed-schema " "buckets.", policy != IneligiblePredicatePolicy::kError); - return {}; + return nullptr; } } else if (matchExpr->matchType() == MatchExpression::MATCH_IN) { // {a: {$in: [X, Y]}} is equivalent to {$or: [ {a: X}, {a: Y} ]}. @@ -921,11 +609,11 @@ BucketSpec::BucketPredicate BucketSpec::createPredicatesOnBucketLevelField( } } if (alwaysTrue) - return {}; + return nullptr; // As above, no special case for an empty IN: returning nullptr would be incorrect because // it means 'always-true', here. - return {std::move(result), nullptr}; + return result; } return handleIneligible(policy, matchExpr, "can't handle this predicate"); } @@ -969,10 +657,12 @@ BSONObj BucketSpec::pushdownPredicate( BucketSpec{ tsOptions.getTimeField().toString(), metaField.map([](StringData s) { return s.toString(); }), - // Since we are operating on a collection, not a query-result, - // there are no inclusion/exclusion projections we need to apply - // to the buckets before unpacking. So we can use default values for the rest of - // the arguments. + // Since we are operating on a collection, not a query-result, there are no + // inclusion/exclusion projections we need to apply to the buckets before + // unpacking. + {}, + // And there are no computed projections. + {}, }, maxSpanSeconds, collationMatchesDefault, @@ -981,14 +671,13 @@ BSONObj BucketSpec::pushdownPredicate( includeMetaField, assumeNoMixedSchemaData, policy) - .loosePredicate : nullptr; BSONObjBuilder result; if (metaOnlyPredicate) - metaOnlyPredicate->serialize(&result, {}); + metaOnlyPredicate->serialize(&result); if (bucketMetricPredicate) - bucketMetricPredicate->serialize(&result, {}); + bucketMetricPredicate->serialize(&result); return result.obj(); } @@ -1004,15 +693,11 @@ public: const Value& metaValue, bool includeTimeField, bool includeMetaField) = 0; - virtual bool getNext(BSONObjBuilder& builder, - const BucketSpec& spec, - const BSONElement& metaValue, - bool includeTimeField, - bool includeMetaField) = 0; virtual void extractSingleMeasurement(MutableDocument& measurement, int j, const BucketSpec& spec, const std::set<std::string>& unpackFieldsToIncludeExclude, + BucketUnpacker::Behavior behavior, const BSONObj& bucket, const Value& metaValue, bool includeTimeField, @@ -1060,15 +745,11 @@ public: const Value& metaValue, bool includeTimeField, bool includeMetaField) override; - bool getNext(BSONObjBuilder& builder, - const BucketSpec& spec, - const BSONElement& metaValue, - bool includeTimeField, - bool includeMetaField) override; void extractSingleMeasurement(MutableDocument& measurement, int j, const BucketSpec& spec, const std::set<std::string>& unpackFieldsToIncludeExclude, + BucketUnpacker::Behavior behavior, const BSONObj& bucket, const Value& metaValue, bool includeTimeField, @@ -1080,7 +761,7 @@ private: BSONObjIterator _timeFieldIter; // Iterators used to unpack the columns of the above bucket that are populated during the reset - // phase according to the provided 'BucketSpec'. + // phase according to the provided 'Behavior' and 'BucketSpec'. std::vector<std::pair<std::string, BSONObjIterator>> _fieldIters; }; @@ -1150,37 +831,12 @@ bool BucketUnpackerV1::getNext(MutableDocument& measurement, return _timeFieldIter.more(); } -bool BucketUnpackerV1::getNext(BSONObjBuilder& builder, - const BucketSpec& spec, - const BSONElement& metaValue, - bool includeTimeField, - bool includeMetaField) { - auto&& timeElem = _timeFieldIter.next(); - if (includeTimeField) { - builder.appendAs(timeElem, spec.timeField()); - } - - // Includes metaField when we're instructed to do so and metaField value exists. - if (includeMetaField && !metaValue.eoo()) { - builder.appendAs(metaValue, *spec.metaField()); - } - - const auto& currentIdx = timeElem.fieldNameStringData(); - for (auto&& [colName, colIter] : _fieldIters) { - if (auto&& elem = *colIter; colIter.more() && elem.fieldNameStringData() == currentIdx) { - builder.appendAs(elem, colName); - colIter.advance(elem); - } - } - - return _timeFieldIter.more(); -} - void BucketUnpackerV1::extractSingleMeasurement( MutableDocument& measurement, int j, const BucketSpec& spec, const std::set<std::string>& unpackFieldsToIncludeExclude, + BucketUnpacker::Behavior behavior, const BSONObj& bucket, const Value& metaValue, bool includeTimeField, @@ -1195,7 +851,7 @@ void BucketUnpackerV1::extractSingleMeasurement( for (auto&& dataElem : dataRegion) { auto colName = dataElem.fieldNameStringData(); - if (!determineIncludeField(colName, spec.behavior(), unpackFieldsToIncludeExclude)) { + if (!determineIncludeField(colName, behavior, unpackFieldsToIncludeExclude)) { continue; } auto value = dataElem[targetIdx]; @@ -1223,15 +879,11 @@ public: const Value& metaValue, bool includeTimeField, bool includeMetaField) override; - bool getNext(BSONObjBuilder& builder, - const BucketSpec& spec, - const BSONElement& metaValue, - bool includeTimeField, - bool includeMetaField) override; void extractSingleMeasurement(MutableDocument& measurement, int j, const BucketSpec& spec, const std::set<std::string>& unpackFieldsToIncludeExclude, + BucketUnpacker::Behavior behavior, const BSONObj& bucket, const Value& metaValue, bool includeTimeField, @@ -1261,7 +913,7 @@ private: ColumnStore _timeColumn; // Iterators used to unpack the columns of the above bucket that are populated during the reset - // phase according to the provided 'BucketSpec'. + // phase according to the provided 'Behavior' and 'BucketSpec'. std::vector<ColumnStore> _fieldColumns; // Element count @@ -1316,43 +968,12 @@ bool BucketUnpackerV2::getNext(MutableDocument& measurement, return _timeColumn.it != _timeColumn.end; } -bool BucketUnpackerV2::getNext(BSONObjBuilder& builder, - const BucketSpec& spec, - const BSONElement& metaValue, - bool includeTimeField, - bool includeMetaField) { - // Get element and increment iterator - const auto& timeElem = *_timeColumn.it; - if (includeTimeField) { - builder.appendAs(timeElem, spec.timeField()); - } - ++_timeColumn.it; - - // Includes metaField when we're instructed to do so and metaField value exists. - if (includeMetaField && !metaValue.eoo()) { - builder.appendAs(metaValue, *spec.metaField()); - } - - for (auto& fieldColumn : _fieldColumns) { - uassert(7026803, - "Bucket unexpectedly contained fewer values than count", - fieldColumn.it != fieldColumn.end); - const BSONElement& elem = *fieldColumn.it; - // EOO represents missing field - if (!elem.eoo()) { - builder.appendAs(elem, fieldColumn.column.name()); - } - ++fieldColumn.it; - } - - return _timeColumn.it != _timeColumn.end; -} - void BucketUnpackerV2::extractSingleMeasurement( MutableDocument& measurement, int j, const BucketSpec& spec, const std::set<std::string>& unpackFieldsToIncludeExclude, + BucketUnpacker::Behavior behavior, const BSONObj& bucket, const Value& metaValue, bool includeTimeField, @@ -1388,16 +1009,12 @@ std::size_t BucketUnpackerV2::numberOfFields() { BucketSpec::BucketSpec(const std::string& timeField, const boost::optional<std::string>& metaField, const std::set<std::string>& fields, - Behavior behavior, - const std::set<std::string>& computedProjections, - bool usesExtendedRange) + const std::set<std::string>& computedProjections) : _fieldSet(fields), - _behavior(behavior), _computedMetaProjFields(computedProjections), _timeField(timeField), _timeFieldHashed(FieldNameHasher().hashedFieldName(_timeField)), - _metaField(metaField), - _usesExtendedRange(usesExtendedRange) { + _metaField(metaField) { if (_metaField) { _metaFieldHashed = FieldNameHasher().hashedFieldName(*_metaField); } @@ -1405,12 +1022,10 @@ BucketSpec::BucketSpec(const std::string& timeField, BucketSpec::BucketSpec(const BucketSpec& other) : _fieldSet(other._fieldSet), - _behavior(other._behavior), _computedMetaProjFields(other._computedMetaProjFields), _timeField(other._timeField), _timeFieldHashed(HashedFieldName{_timeField, other._timeFieldHashed->hash()}), - _metaField(other._metaField), - _usesExtendedRange(other._usesExtendedRange) { + _metaField(other._metaField) { if (_metaField) { _metaFieldHashed = HashedFieldName{*_metaField, other._metaFieldHashed->hash()}; } @@ -1418,12 +1033,10 @@ BucketSpec::BucketSpec(const BucketSpec& other) BucketSpec::BucketSpec(BucketSpec&& other) : _fieldSet(std::move(other._fieldSet)), - _behavior(other._behavior), _computedMetaProjFields(std::move(other._computedMetaProjFields)), _timeField(std::move(other._timeField)), _timeFieldHashed(HashedFieldName{_timeField, other._timeFieldHashed->hash()}), - _metaField(std::move(other._metaField)), - _usesExtendedRange(other._usesExtendedRange) { + _metaField(std::move(other._metaField)) { if (_metaField) { _metaFieldHashed = HashedFieldName{*_metaField, other._metaFieldHashed->hash()}; } @@ -1432,7 +1045,6 @@ BucketSpec::BucketSpec(BucketSpec&& other) BucketSpec& BucketSpec::operator=(const BucketSpec& other) { if (&other != this) { _fieldSet = other._fieldSet; - _behavior = other._behavior; _computedMetaProjFields = other._computedMetaProjFields; _timeField = other._timeField; _timeFieldHashed = HashedFieldName{_timeField, other._timeFieldHashed->hash()}; @@ -1440,7 +1052,6 @@ BucketSpec& BucketSpec::operator=(const BucketSpec& other) { if (_metaField) { _metaFieldHashed = HashedFieldName{*_metaField, other._metaFieldHashed->hash()}; } - _usesExtendedRange = other._usesExtendedRange; } return *this; } @@ -1482,8 +1093,8 @@ BucketUnpacker::BucketUnpacker(BucketUnpacker&& other) = default; BucketUnpacker::~BucketUnpacker() = default; BucketUnpacker& BucketUnpacker::operator=(BucketUnpacker&& rhs) = default; -BucketUnpacker::BucketUnpacker(BucketSpec spec) { - setBucketSpec(std::move(spec)); +BucketUnpacker::BucketUnpacker(BucketSpec spec, Behavior unpackerBehavior) { + setBucketSpecAndBehavior(std::move(spec), unpackerBehavior); } void BucketUnpacker::addComputedMetaProjFields(const std::vector<StringData>& computedFieldNames) { @@ -1492,7 +1103,7 @@ void BucketUnpacker::addComputedMetaProjFields(const std::vector<StringData>& co // If we're already specifically including fields, we need to add the computed fields to // the included field set to indicate they're in the output doc. - if (_spec.behavior() == BucketSpec::Behavior::kInclude) { + if (_unpackerBehavior == BucketUnpacker::Behavior::kInclude) { _spec.addIncludeExcludeField(field); } else { // Since exclude is applied after addComputedMetaProjFields, we must erase the new field @@ -1533,27 +1144,6 @@ Document BucketUnpacker::getNext() { return measurement.freeze(); } -BSONObj BucketUnpacker::getNextBson() { - tassert(7026800, "'getNextBson()' requires the bucket to be owned", _bucket.isOwned()); - tassert(7026801, "'getNextBson()' was called after the bucket has been exhausted", hasNext()); - tassert(7026802, - "'getNextBson()' cannot return max and min time as metadata", - !_includeMaxTimeAsMetadata && !_includeMinTimeAsMetadata); - - BSONObjBuilder builder; - _hasNext = _unpackingImpl->getNext( - builder, _spec, _metaBSONElem, _includeTimeField, _includeMetaField); - - // Add computed meta projections. - for (auto&& name : _spec.computedMetaProjFields()) { - if (_computedMetaProjections[name]) { - builder.appendAs(_computedMetaProjections[name], name); - } - } - - return builder.obj(); -} - Document BucketUnpacker::extractSingleMeasurement(int j) { tassert(5422101, "'extractSingleMeasurment' expects j to be greater than or equal to zero and less than " @@ -1565,6 +1155,7 @@ Document BucketUnpacker::extractSingleMeasurement(int j) { j, _spec, fieldsToIncludeExcludeDuringUnpack(), + _unpackerBehavior, _bucket, _metaValue, _includeTimeField, @@ -1578,10 +1169,9 @@ Document BucketUnpacker::extractSingleMeasurement(int j) { return measurement.freeze(); } -void BucketUnpacker::reset(BSONObj&& bucket, bool bucketMatchedQuery) { +void BucketUnpacker::reset(BSONObj&& bucket) { _unpackingImpl.reset(); _bucket = std::move(bucket); - _bucketMatchedQuery = bucketMatchedQuery; uassert(5346510, "An empty bucket cannot be unpacked", !_bucket.isEmpty()); auto&& dataRegion = _bucket.getField(timeseries::kBucketDataFieldName).Obj(); @@ -1596,8 +1186,7 @@ void BucketUnpacker::reset(BSONObj&& bucket, bool bucketMatchedQuery) { "The $_internalUnpackBucket stage requires the data region to have a timeField object", timeFieldElem); - _metaBSONElem = _bucket[timeseries::kBucketMetaFieldName]; - _metaValue = Value{_metaBSONElem}; + _metaValue = Value{_bucket[timeseries::kBucketMetaFieldName]}; if (_spec.metaField()) { // The spec indicates that there might be a metadata region. Missing metadata in // measurements is expressed with missing metadata in a bucket. But we disallow undefined @@ -1679,10 +1268,10 @@ void BucketUnpacker::reset(BSONObj&& bucket, bool bucketMatchedQuery) { continue; } - // Includes a field when '_spec.behavior()' is 'kInclude' and it's found in 'fieldSet' or - // _spec.behavior() is 'kExclude' and it's not found in 'fieldSet'. + // Includes a field when '_unpackerBehavior' is 'kInclude' and it's found in 'fieldSet' or + // _unpackerBehavior is 'kExclude' and it's not found in 'fieldSet'. if (determineIncludeField( - colName, _spec.behavior(), fieldsToIncludeExcludeDuringUnpack())) { + colName, _unpackerBehavior, fieldsToIncludeExcludeDuringUnpack())) { _unpackingImpl->addField(elem); } } @@ -1733,7 +1322,7 @@ int BucketUnpacker::computeMeasurementCount(const BSONObj& bucket, StringData ti } void BucketUnpacker::determineIncludeTimeField() { - const bool isInclude = _spec.behavior() == BucketSpec::Behavior::kInclude; + const bool isInclude = _unpackerBehavior == BucketUnpacker::Behavior::kInclude; const bool fieldSetContainsTime = _spec.fieldSet().find(_spec.timeField()) != _spec.fieldSet().end(); @@ -1753,32 +1342,27 @@ void BucketUnpacker::eraseMetaFromFieldSetAndDetermineIncludeMeta() { } else if (auto itr = _spec.fieldSet().find(*_spec.metaField()); itr != _spec.fieldSet().end()) { _spec.removeIncludeExcludeField(*_spec.metaField()); - _includeMetaField = _spec.behavior() == BucketSpec::Behavior::kInclude; + _includeMetaField = _unpackerBehavior == BucketUnpacker::Behavior::kInclude; } else { - _includeMetaField = _spec.behavior() == BucketSpec::Behavior::kExclude; + _includeMetaField = _unpackerBehavior == BucketUnpacker::Behavior::kExclude; } } -void BucketUnpacker::eraseUnneededComputedMetaProjFields() { - // If this is an inclusion spec and the current computed field is not part of in the include - // fields, it means the computed field should not be available after the current unpack stage. - // Similarly, for exclusion spec, if the current computed field is part of the exclude fields, - // the computed fields should not be available after the current unpack stage. This can happen - // if there was a $project stage after a $addFields stage. - bool removeIfInFieldSet = _spec.behavior() == BucketSpec::Behavior::kExclude; - auto conditionToErase = [&](const std::string& computedField) { - bool inFieldSet = _spec.fieldSet().find(computedField) != _spec.fieldSet().end(); - return inFieldSet == removeIfInFieldSet; - }; - _spec.eraseIfPredTrueFromComputedMetaProjFields(conditionToErase); +void BucketUnpacker::eraseExcludedComputedMetaProjFields() { + if (_unpackerBehavior == BucketUnpacker::Behavior::kExclude) { + for (const auto& field : _spec.fieldSet()) { + _spec.eraseFromComputedMetaProjFields(field); + } + } } -void BucketUnpacker::setBucketSpec(BucketSpec&& bucketSpec) { +void BucketUnpacker::setBucketSpecAndBehavior(BucketSpec&& bucketSpec, Behavior behavior) { + _unpackerBehavior = behavior; _spec = std::move(bucketSpec); eraseMetaFromFieldSetAndDetermineIncludeMeta(); determineIncludeTimeField(); - eraseUnneededComputedMetaProjFields(); + eraseExcludedComputedMetaProjFields(); _includeMinTimeAsMetadata = _spec.includeMinTimeAsMetadata; _includeMaxTimeAsMetadata = _spec.includeMaxTimeAsMetadata; @@ -1799,7 +1383,7 @@ const std::set<std::string>& BucketUnpacker::fieldsToIncludeExcludeDuringUnpack( _unpackFieldsToIncludeExclude = std::set<std::string>(); const auto& metaProjFields = _spec.computedMetaProjFields(); - if (_spec.behavior() == BucketSpec::Behavior::kInclude) { + if (_unpackerBehavior == BucketUnpacker::Behavior::kInclude) { // For include, we unpack fieldSet - metaProjFields. for (auto&& field : _spec.fieldSet()) { if (metaProjFields.find(field) == metaProjFields.cend()) { diff --git a/src/mongo/db/exec/bucket_unpacker.h b/src/mongo/db/exec/bucket_unpacker.h index 3c63d6abe49..287bd9f2540 100644 --- a/src/mongo/db/exec/bucket_unpacker.h +++ b/src/mongo/db/exec/bucket_unpacker.h @@ -54,18 +54,11 @@ namespace mongo { */ class BucketSpec { public: - // When unpackin buckets with kInclude we must produce measurements that contain the - // set of fields. Otherwise, if the kExclude option is used, the measurements will include the - // set difference between all fields in the bucket and the provided fields. - enum class Behavior { kInclude, kExclude }; - BucketSpec() = default; BucketSpec(const std::string& timeField, const boost::optional<std::string>& metaField, const std::set<std::string>& fields = {}, - Behavior behavior = Behavior::kExclude, - const std::set<std::string>& computedProjections = {}, - bool usesExtendedRange = false); + const std::set<std::string>& computedProjections = {}); BucketSpec(const BucketSpec&); BucketSpec(BucketSpec&&); @@ -99,14 +92,6 @@ public: return _fieldSet; } - void setBehavior(Behavior behavior) { - _behavior = behavior; - } - - Behavior behavior() const { - return _behavior; - } - void addComputedMetaProjFields(const StringData& field) { _computedMetaProjFields.emplace(field); } @@ -115,24 +100,8 @@ public: return _computedMetaProjFields; } - // Remove fields that the predicate function evaluates to true for. - void eraseIfPredTrueFromComputedMetaProjFields(const std::function<bool(std::string)> pred) { - auto it = _computedMetaProjFields.begin(); - while (it != _computedMetaProjFields.end()) { - if (pred(*it)) { - it = _computedMetaProjFields.erase(it); - } else { - ++it; - } - } - } - - void setUsesExtendedRange(bool usesExtendedRange) { - _usesExtendedRange = usesExtendedRange; - } - - bool usesExtendedRange() const { - return _usesExtendedRange; + void eraseFromComputedMetaProjFields(const std::string& field) { + _computedMetaProjFields.erase(field); } // Returns whether 'field' depends on a pushed down $addFields or computed $project. @@ -149,45 +118,27 @@ public: kError, }; - struct BucketPredicate { - // A loose predicate is a predicate which returns true when any measures of a bucket - // matches. - std::unique_ptr<MatchExpression> loosePredicate; - - // A tight predicate is a predicate which returns true when all measures of a bucket - // matches. - std::unique_ptr<MatchExpression> tightPredicate; - }; - /** - * Takes a predicate after $_internalUnpackBucket as an argument and attempts to rewrite it as - * new predicates on the 'control' field. There will be a 'loose' predicate that will match if - * some of the event field matches, also a 'tight' predicate that will match if all of the event - * field matches. + * Takes a predicate after $_internalUnpackBucket on a bucketed field as an argument and + * attempts to map it to a new predicate on the 'control' field. For example, the predicate + * {a: {$gt: 5}} will generate the predicate {control.max.a: {$_internalExprGt: 5}}, which will + * be added before the $_internalUnpackBucket stage. * - * For example, the event level predicate {a: {$gt: 5}} will generate the loose predicate - * {control.max.a: {$_internalExprGt: 5}}. The loose predicate will be added before the - * $_internalUnpackBucket stage to filter out buckets with no match. - * - * Ideally, we'd like to add a tight predicate such as {control.min.a: {$_internalExprGt: 5}} to - * evaluate the filter on bucket level to avoid unnecessary event level evaluation. However, a - * bucket might contain events with missing fields that are skipped when computing the controls, - * so in reality we only add a tight predicate on timeField which is required to exist. - * - * If the original predicate is on the bucket's timeField we may also create a new loose - * predicate on the '_id' field (as it incorporates min time for the bucket) to assist in index - * utilization. For example, the predicate {time: {$lt: new Date(...)}} will generate the - * following predicate: + * If the original predicate is on the bucket's timeField we may also create a new predicate + * on the '_id' field to assist in index utilization. For example, the predicate + * {time: {$lt: new Date(...)}} will generate the following predicate: * {$and: [ * {_id: {$lt: ObjectId(...)}}, * {control.min.time: {$_internalExprLt: new Date(...)}} * ]} * - * If the provided predicate is ineligible for this mapping and using - * IneligiblePredicatePolicy::kIgnore, both loose and tight predicates will be set to nullptr. - * When using IneligiblePredicatePolicy::kError it raises a user error. + * If the provided predicate is ineligible for this mapping, the function will return a nullptr. + * This should be interpreted as an always-true predicate. + * + * When using IneligiblePredicatePolicy::kIgnore, if the predicate can't be pushed down, it + * returns null. When using IneligiblePredicatePolicy::kError it raises a user error. */ - static BucketPredicate createPredicatesOnBucketLevelField( + static std::unique_ptr<MatchExpression> createPredicatesOnBucketLevelField( const MatchExpression* matchExpr, const BucketSpec& bucketSpec, int bucketMaxSpanSeconds, @@ -233,7 +184,6 @@ public: private: // The set of field names in the data region that should be included or excluded. std::set<std::string> _fieldSet; - Behavior _behavior = Behavior::kExclude; // Set of computed meta field projection names. Added at the end of materialized // measurements. @@ -244,7 +194,6 @@ private: boost::optional<std::string> _metaField = boost::none; boost::optional<HashedFieldName> _metaFieldHashed = boost::none; - bool _usesExtendedRange = false; }; /** @@ -252,6 +201,10 @@ private: */ class BucketUnpacker { public: + // When BucketUnpacker is created with kInclude it must produce measurements that contain the + // set of fields. Otherwise, if the kExclude option is used, the measurements will include the + // set difference between all fields in the bucket and the provided fields. + enum class Behavior { kInclude, kExclude }; /** * Returns the number of measurements in the bucket in O(1) time. */ @@ -261,7 +214,7 @@ public: static const std::set<StringData> reservedBucketFieldNames; BucketUnpacker(); - BucketUnpacker(BucketSpec spec); + BucketUnpacker(BucketSpec spec, Behavior unpackerBehavior); BucketUnpacker(const BucketUnpacker& other) = delete; BucketUnpacker(BucketUnpacker&& other); ~BucketUnpacker(); @@ -275,11 +228,6 @@ public: Document getNext(); /** - * Similar to the previous method, but return a BSON object instead. - */ - BSONObj getNextBson(); - - /** * This method will extract the j-th measurement from the bucket. A precondition of this method * is that j >= 0 && j <= the number of measurements within the underlying bucket. */ @@ -298,6 +246,7 @@ public: */ BucketUnpacker copy() const { BucketUnpacker unpackerCopy; + unpackerCopy._unpackerBehavior = _unpackerBehavior; unpackerCopy._spec = _spec; unpackerCopy._includeMetaField = _includeMetaField; unpackerCopy._includeTimeField = _includeTimeField; @@ -307,10 +256,10 @@ public: /** * This resets the unpacker to prepare to unpack a new bucket described by the given document. */ - void reset(BSONObj&& bucket, bool bucketMatchedQuery = false); + void reset(BSONObj&& bucket); - BucketSpec::Behavior behavior() const { - return _spec.behavior(); + Behavior behavior() const { + return _unpackerBehavior; } const BucketSpec& bucketSpec() const { @@ -321,10 +270,6 @@ public: return _bucket; } - bool bucketMatchedQuery() const { - return _bucketMatchedQuery; - } - bool includeMetaField() const { return _includeMetaField; } @@ -361,7 +306,7 @@ public: return std::string{timeseries::kControlMaxFieldNamePrefix} + field; } - void setBucketSpec(BucketSpec&& bucketSpec); + void setBucketSpecAndBehavior(BucketSpec&& bucketSpec, Behavior behavior); void setIncludeMinTimeAsMetadata(); void setIncludeMaxTimeAsMetadata(); @@ -382,19 +327,16 @@ private: // included in the materialized measurements. void eraseMetaFromFieldSetAndDetermineIncludeMeta(); - // Erase computed meta projection fields if they are present in the exclusion field set or if - // they are not present in the inclusion set. - void eraseUnneededComputedMetaProjFields(); + // Erase computed meta projection fields if they are present in the exclusion field set. + void eraseExcludedComputedMetaProjFields(); BucketSpec _spec; + Behavior _unpackerBehavior; std::unique_ptr<UnpackingImpl> _unpackingImpl; bool _hasNext = false; - // A flag used to mark that the entire bucket matches the following $match predicate. - bool _bucketMatchedQuery = false; - // A flag used to mark that the timestamp value should be materialized in measurements. bool _includeTimeField{false}; @@ -415,8 +357,6 @@ private: // measurement. Value _metaValue; - BSONElement _metaBSONElem; - // Since the bucket min time is the same across all materialized measurements, we can cache the // value in the reset phase and use it to materialize as a metadata field in each measurement // if required by the pipeline. @@ -443,9 +383,9 @@ private: * Determines if an arbitrary field should be included in the materialized measurements. */ inline bool determineIncludeField(StringData fieldName, - BucketSpec::Behavior unpackerBehavior, + BucketUnpacker::Behavior unpackerBehavior, const std::set<std::string>& unpackFieldsToIncludeExclude) { - const bool isInclude = unpackerBehavior == BucketSpec::Behavior::kInclude; + const bool isInclude = unpackerBehavior == BucketUnpacker::Behavior::kInclude; const bool unpackFieldsContains = unpackFieldsToIncludeExclude.find(fieldName.toString()) != unpackFieldsToIncludeExclude.cend(); return isInclude == unpackFieldsContains; diff --git a/src/mongo/db/exec/bucket_unpacker_test.cpp b/src/mongo/db/exec/bucket_unpacker_test.cpp index 1d62aae3768..8ee0f4e05f5 100644 --- a/src/mongo/db/exec/bucket_unpacker_test.cpp +++ b/src/mongo/db/exec/bucket_unpacker_test.cpp @@ -57,12 +57,12 @@ public: * before actually doing any unpacking. */ BucketUnpacker makeBucketUnpacker(std::set<std::string> fields, - BucketSpec::Behavior behavior, + BucketUnpacker::Behavior behavior, BSONObj bucket, boost::optional<std::string> metaFieldName = boost::none) { - auto spec = - BucketSpec{kUserDefinedTimeName.toString(), metaFieldName, std::move(fields), behavior}; - BucketUnpacker unpacker{std::move(spec)}; + auto spec = BucketSpec{kUserDefinedTimeName.toString(), metaFieldName, std::move(fields)}; + + BucketUnpacker unpacker{std::move(spec), behavior}; unpacker.reset(std::move(bucket)); return unpacker; } @@ -72,13 +72,12 @@ public: * the given 'bucket'. Asserts that 'reset()' throws the given 'errorCode'. */ void assertUnpackerThrowsCode(std::set<std::string> fields, - BucketSpec::Behavior behavior, + BucketUnpacker::Behavior behavior, BSONObj bucket, boost::optional<std::string> metaFieldName, int errorCode) { - auto spec = - BucketSpec{kUserDefinedTimeName.toString(), metaFieldName, std::move(fields), behavior}; - BucketUnpacker unpacker{std::move(spec)}; + auto spec = BucketSpec{kUserDefinedTimeName.toString(), metaFieldName, std::move(fields)}; + BucketUnpacker unpacker{std::move(spec), behavior}; ASSERT_THROWS_CODE(unpacker.reset(std::move(bucket)), AssertionException, errorCode); } @@ -170,11 +169,6 @@ public: } return root.obj(); } - - bool computedMetaProjFieldsContainsField(std::set<std::string>& computedMetaProjFields, - std::string field) { - return computedMetaProjFields.find(field) != computedMetaProjFields.end(); - } }; TEST_F(BucketUnpackerTest, UnpackBasicIncludeAllMeasurementFields) { @@ -187,7 +181,7 @@ TEST_F(BucketUnpackerTest, UnpackBasicIncludeAllMeasurementFields) { "a:{'0':1, '1':2}, b:{'1':1}}}"); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(bucket), kUserDefinedMetaName.toString()); @@ -211,7 +205,7 @@ TEST_F(BucketUnpackerTest, ExcludeASingleField) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); @@ -239,7 +233,7 @@ TEST_F(BucketUnpackerTest, EmptyIncludeGetsEmptyMeasurements) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(bucket), kUserDefinedMetaName.toString()); @@ -265,7 +259,7 @@ TEST_F(BucketUnpackerTest, EmptyExcludeMaterializesAllFields) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -293,7 +287,7 @@ TEST_F(BucketUnpackerTest, SparseColumnsWhereOneColumnIsExhaustedBeforeTheOther) auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -320,7 +314,7 @@ TEST_F(BucketUnpackerTest, UnpackBasicIncludeWithDollarPrefix) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -347,7 +341,7 @@ TEST_F(BucketUnpackerTest, BucketsWithMetadataOnly) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -373,7 +367,7 @@ TEST_F(BucketUnpackerTest, UnorderedRowKeysDoesntAffectMaterialization) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -403,7 +397,7 @@ TEST_F(BucketUnpackerTest, MissingMetaFieldDoesntMaterializeMetadata) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -430,7 +424,7 @@ TEST_F(BucketUnpackerTest, MissingMetaFieldDoesntMaterializeMetadataUnorderedKey auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -458,7 +452,7 @@ TEST_F(BucketUnpackerTest, ExcludedMetaFieldDoesntMaterializeMetadataWhenBucketH auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -485,7 +479,7 @@ TEST_F(BucketUnpackerTest, UnpackerResetThrowsOnUndefinedMeta) { auto test = [&](BSONObj bucket) { assertUnpackerThrowsCode(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString(), 5369600); @@ -505,7 +499,7 @@ TEST_F(BucketUnpackerTest, UnpackerResetThrowsOnUnexpectedMeta) { auto test = [&](BSONObj bucket) { assertUnpackerThrowsCode(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), boost::none /* no metaField provided */, 5369601); @@ -524,7 +518,7 @@ TEST_F(BucketUnpackerTest, NullMetaInBucketMaterializesAsNull) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -556,7 +550,7 @@ TEST_F(BucketUnpackerTest, GetNextHandlesMissingMetaInBucket) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker(fields, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, std::move(bucket), kUserDefinedMetaName.toString()); ASSERT_TRUE(unpacker.hasNext()); @@ -585,7 +579,7 @@ TEST_F(BucketUnpackerTest, EmptyDataRegionInBucketIsTolerated) { auto test = [&](BSONObj bucket) { auto unpacker = makeBucketUnpacker( - fields, BucketSpec::Behavior::kExclude, bucket, kUserDefinedMetaName.toString()); + fields, BucketUnpacker::Behavior::kExclude, bucket, kUserDefinedMetaName.toString()); ASSERT_FALSE(unpacker.hasNext()); }; @@ -597,7 +591,7 @@ TEST_F(BucketUnpackerTest, UnpackerResetThrowsOnEmptyBucket) { auto bucket = Document{}; assertUnpackerThrowsCode(std::move(fields), - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, bucket.toBson(), kUserDefinedMetaName.toString(), 5346510); @@ -615,125 +609,51 @@ TEST_F(BucketUnpackerTest, EraseMetaFromFieldSetAndDetermineIncludeMeta) { } })"); auto unpacker = makeBucketUnpacker(empFields, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(bucket), kUserDefinedMetaName.toString()); // Tests a spec with 'metaField' in include list. std::set<std::string> fields{kUserDefinedMetaName.toString()}; - auto specWithMetaInclude = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(fields), - BucketSpec::Behavior::kInclude}; + auto specWithMetaInclude = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(fields)}; // This calls eraseMetaFromFieldSetAndDetermineIncludeMeta. - unpacker.setBucketSpec(std::move(specWithMetaInclude)); + unpacker.setBucketSpecAndBehavior(std::move(specWithMetaInclude), + BucketUnpacker::Behavior::kInclude); ASSERT_TRUE(unpacker.includeMetaField()); ASSERT_EQ(unpacker.bucketSpec().fieldSet().count(kUserDefinedMetaName.toString()), 0); std::set<std::string> fieldsNoMetaInclude{"foo"}; auto specWithFooInclude = BucketSpec{kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), - std::move(fieldsNoMetaInclude), - BucketSpec::Behavior::kInclude}; + std::move(fieldsNoMetaInclude)}; std::set<std::string> fieldsNoMetaExclude{"foo"}; auto specWithFooExclude = BucketSpec{kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), - std::move(fieldsNoMetaExclude), - BucketSpec::Behavior::kExclude}; + std::move(fieldsNoMetaExclude)}; - unpacker.setBucketSpec(std::move(specWithFooExclude)); + unpacker.setBucketSpecAndBehavior(std::move(specWithFooExclude), + BucketUnpacker::Behavior::kExclude); ASSERT_TRUE(unpacker.includeMetaField()); - unpacker.setBucketSpec(std::move(specWithFooInclude)); + unpacker.setBucketSpecAndBehavior(std::move(specWithFooInclude), + BucketUnpacker::Behavior::kInclude); ASSERT_FALSE(unpacker.includeMetaField()); // Tests a spec with 'metaField' not in exclude list. std::set<std::string> excludeFields{}; - auto specMetaExclude = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(excludeFields), - BucketSpec::Behavior::kExclude}; - + auto specMetaExclude = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(excludeFields)}; auto specMetaInclude = specMetaExclude; - specMetaInclude.setBehavior(BucketSpec::Behavior::kInclude); - - unpacker.setBucketSpec(std::move(specMetaExclude)); + unpacker.setBucketSpecAndBehavior(std::move(specMetaExclude), + BucketUnpacker::Behavior::kExclude); ASSERT_TRUE(unpacker.includeMetaField()); - unpacker.setBucketSpec(std::move(specMetaInclude)); + unpacker.setBucketSpecAndBehavior(std::move(specMetaInclude), + BucketUnpacker::Behavior::kInclude); ASSERT_FALSE(unpacker.includeMetaField()); } -TEST_F(BucketUnpackerTest, EraseUnneededComputedMetaProjFieldsWithInclusiveProject) { - auto bucket = fromjson(R"( -{ - control: {version: 1}, - data: { - _id: {'0':4, '1':5, '2':6}, - time: {'0':4, '1': 5, '2': 6} - } -})"); - std::set<std::string> unpackerFields{kUserDefinedTimeName.toString()}; - auto unpacker = makeBucketUnpacker(unpackerFields, - BucketSpec::Behavior::kInclude, - std::move(bucket), - kUserDefinedMetaName.toString()); - - // Add fields to '_computedMetaProjFields'. - unpacker.addComputedMetaProjFields({"hello"_sd, "bye"_sd}); - auto computedMetaProjFields = unpacker.bucketSpec().computedMetaProjFields(); - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "hello")); - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "bye")); - - auto spec = unpacker.bucketSpec(); - std::set<std::string> includeFields{kUserDefinedTimeName.toString(), "bye"}; - spec.setFieldSet(includeFields); - spec.setBehavior(BucketSpec::Behavior::kInclude); - - // This calls eraseUnneededComputedMetaProjFields(). - unpacker.setBucketSpec(std::move(spec)); - computedMetaProjFields = unpacker.bucketSpec().computedMetaProjFields(); - // As "hello" was not in the includes, it should be removed. - ASSERT_FALSE(computedMetaProjFieldsContainsField(computedMetaProjFields, "hello")); - // As "bye" was in the includes, it should still be in '_computedMetaProjFields'. - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "bye")); -} - -TEST_F(BucketUnpackerTest, EraseUnneededComputedMetaProjFieldsWithExclusiveProject) { - auto bucket = fromjson(R"( -{ - control: {version: 1}, - data: { - _id: {'0':4, '1':5, '2':6}, - time: {'0':4, '1': 5, '2': 6} - } -})"); - std::set<std::string> unpackerFields{kUserDefinedTimeName.toString()}; - auto unpacker = makeBucketUnpacker(unpackerFields, - BucketSpec::Behavior::kInclude, - std::move(bucket), - kUserDefinedMetaName.toString()); - - // Add fields to '_computedMetaProjFields'. - unpacker.addComputedMetaProjFields({"hello"_sd, "bye"_sd}); - auto computedMetaProjFields = unpacker.bucketSpec().computedMetaProjFields(); - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "hello")); - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "bye")); - - auto spec = unpacker.bucketSpec(); - std::set<std::string> excludeFields{kUserDefinedTimeName.toString(), "bye"}; - spec.setFieldSet(excludeFields); - spec.setBehavior(BucketSpec::Behavior::kExclude); - - // This calls eraseUnneededComputedMetaProjFields(). - unpacker.setBucketSpec(std::move(spec)); - computedMetaProjFields = unpacker.bucketSpec().computedMetaProjFields(); - // As "hello" was not excluded, it should still exist. - ASSERT_TRUE(computedMetaProjFieldsContainsField(computedMetaProjFields, "hello")); - // As "bye" was in the excludes, it should be removed from '_computedMetaProjFields'. - ASSERT_FALSE(computedMetaProjFieldsContainsField(computedMetaProjFields, "bye")); -} - TEST_F(BucketUnpackerTest, DetermineIncludeTimeField) { auto bucket = fromjson(R"( { @@ -745,25 +665,21 @@ TEST_F(BucketUnpackerTest, DetermineIncludeTimeField) { })"); std::set<std::string> unpackerFields{kUserDefinedTimeName.toString()}; auto unpacker = makeBucketUnpacker(unpackerFields, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(bucket), kUserDefinedMetaName.toString()); std::set<std::string> includeFields{kUserDefinedTimeName.toString()}; - auto includeSpec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(includeFields), - BucketSpec::Behavior::kInclude}; + auto includeSpec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(includeFields)}; // This calls determineIncludeTimeField. - unpacker.setBucketSpec(std::move(includeSpec)); + unpacker.setBucketSpecAndBehavior(std::move(includeSpec), BucketUnpacker::Behavior::kInclude); ASSERT_TRUE(unpacker.includeTimeField()); std::set<std::string> excludeFields{kUserDefinedTimeName.toString()}; - auto excludeSpec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(excludeFields), - BucketSpec::Behavior::kExclude}; - unpacker.setBucketSpec(std::move(excludeSpec)); + auto excludeSpec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(excludeFields)}; + unpacker.setBucketSpecAndBehavior(std::move(excludeSpec), BucketUnpacker::Behavior::kExclude); ASSERT_FALSE(unpacker.includeTimeField()); } @@ -778,26 +694,24 @@ TEST_F(BucketUnpackerTest, DetermineIncludeFieldIncludeMode) { {"data", Document{}}} .toBson(); - auto spec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(fields), - BucketSpec::Behavior::kInclude}; + auto spec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(fields)}; BucketUnpacker includeUnpacker; - includeUnpacker.setBucketSpec(std::move(spec)); + includeUnpacker.setBucketSpecAndBehavior(std::move(spec), BucketUnpacker::Behavior::kInclude); // Need to call reset so that the private method calculateFieldsToIncludeExcludeDuringUnpack() // is called, and _unpackFieldsToIncludeExclude gets filled with fields. includeUnpacker.reset(std::move(bucket)); // Now the spec knows which fields to include/exclude. ASSERT_TRUE(determineIncludeField(kUserDefinedTimeName, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, includeUnpacker.fieldsToIncludeExcludeDuringUnpack())); ASSERT_TRUE(determineIncludeField(includedMeasurementField, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, includeUnpacker.fieldsToIncludeExcludeDuringUnpack())); ASSERT_FALSE(determineIncludeField(excludedMeasurementField, - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, includeUnpacker.fieldsToIncludeExcludeDuringUnpack())); } @@ -812,23 +726,21 @@ TEST_F(BucketUnpackerTest, DetermineIncludeFieldExcludeMode) { {"data", Document{}}} .toBson(); - auto spec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(fields), - BucketSpec::Behavior::kExclude}; + auto spec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(fields)}; BucketUnpacker excludeUnpacker; - excludeUnpacker.setBucketSpec(std::move(spec)); + excludeUnpacker.setBucketSpecAndBehavior(std::move(spec), BucketUnpacker::Behavior::kExclude); excludeUnpacker.reset(std::move(bucket)); ASSERT_FALSE(determineIncludeField(kUserDefinedTimeName, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, excludeUnpacker.fieldsToIncludeExcludeDuringUnpack())); ASSERT_FALSE(determineIncludeField(includedMeasurementField, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, excludeUnpacker.fieldsToIncludeExcludeDuringUnpack())); ASSERT_TRUE(determineIncludeField(excludedMeasurementField, - BucketSpec::Behavior::kExclude, + BucketUnpacker::Behavior::kExclude, excludeUnpacker.fieldsToIncludeExcludeDuringUnpack())); } @@ -846,11 +758,9 @@ auto expectedTimestampObjSize(int32_t rowKeyOffset, int32_t n) { TEST_F(BucketUnpackerTest, ExtractSingleMeasurement) { std::set<std::string> fields{ "_id", kUserDefinedMetaName.toString(), kUserDefinedTimeName.toString(), "a", "b"}; - auto spec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(fields), - BucketSpec::Behavior::kInclude}; - auto unpacker = BucketUnpacker{std::move(spec)}; + auto spec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(fields)}; + auto unpacker = BucketUnpacker{std::move(spec), BucketUnpacker::Behavior::kInclude}; auto d1 = dateFromISOString("2020-02-17T00:00:00.000Z").getValue(); auto d2 = dateFromISOString("2020-02-17T01:00:00.000Z").getValue(); @@ -893,11 +803,9 @@ TEST_F(BucketUnpackerTest, ExtractSingleMeasurement) { TEST_F(BucketUnpackerTest, ExtractSingleMeasurementSparse) { std::set<std::string> fields{ "_id", kUserDefinedMetaName.toString(), kUserDefinedTimeName.toString(), "a", "b"}; - auto spec = BucketSpec{kUserDefinedTimeName.toString(), - kUserDefinedMetaName.toString(), - std::move(fields), - BucketSpec::Behavior::kInclude}; - auto unpacker = BucketUnpacker{std::move(spec)}; + auto spec = BucketSpec{ + kUserDefinedTimeName.toString(), kUserDefinedMetaName.toString(), std::move(fields)}; + auto unpacker = BucketUnpacker{std::move(spec), BucketUnpacker::Behavior::kInclude}; auto d1 = dateFromISOString("2020-02-17T00:00:00.000Z").getValue(); auto d2 = dateFromISOString("2020-02-17T01:00:00.000Z").getValue(); @@ -984,7 +892,7 @@ TEST_F(BucketUnpackerTest, TamperedCompressedCountLess) { auto modifiedCompressedBucket = modifyCompressedBucketElementCount(*compressedBucket, -1); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(modifiedCompressedBucket), kUserDefinedMetaName.toString()); @@ -1019,7 +927,7 @@ TEST_F(BucketUnpackerTest, TamperedCompressedCountMore) { auto modifiedCompressedBucket = modifyCompressedBucketElementCount(*compressedBucket, 1); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(modifiedCompressedBucket), kUserDefinedMetaName.toString()); @@ -1054,7 +962,7 @@ TEST_F(BucketUnpackerTest, TamperedCompressedCountMissing) { auto modifiedCompressedBucket = modifyCompressedBucketElementCount(*compressedBucket, 0); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(modifiedCompressedBucket), kUserDefinedMetaName.toString()); @@ -1091,7 +999,7 @@ TEST_F(BucketUnpackerTest, TamperedCompressedElementMismatchDataField) { modifyCompressedBucketRemoveLastInField(*compressedBucket, "a"_sd); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(modifiedCompressedBucket), kUserDefinedMetaName.toString()); @@ -1126,7 +1034,7 @@ TEST_F(BucketUnpackerTest, TamperedCompressedElementMismatchTimeField) { modifyCompressedBucketRemoveLastInField(*compressedBucket, "time"_sd); auto unpacker = makeBucketUnpacker(std::move(fields), - BucketSpec::Behavior::kInclude, + BucketUnpacker::Behavior::kInclude, std::move(modifiedCompressedBucket), kUserDefinedMetaName.toString()); diff --git a/src/mongo/db/exec/collection_scan.cpp b/src/mongo/db/exec/collection_scan.cpp index 5898ac224d9..506ce18d1ce 100644 --- a/src/mongo/db/exec/collection_scan.cpp +++ b/src/mongo/db/exec/collection_scan.cpp @@ -185,26 +185,9 @@ PlanStage::StageState CollectionScan::doWork(WorkingSetID* out) { << "attempting to resume no longer exists in the collection. " << "recordId: " << recordIdToSeek); } - - if (_params.resumeAfterRecordId && !_params.resumeAfterRecordId->isNull()) { - invariant(!_params.tailable); - invariant(_lastSeenId.isNull()); - // Seek to where we are trying to resume the scan from. Signal a KeyNotFound - // error if the record no longer exists. - // - // Note that we want to return the record *after* this one since we have already - // returned this one prior to the resume. - auto& recordIdToSeek = *_params.resumeAfterRecordId; - if (!_cursor->seekExact(recordIdToSeek)) { - uasserted(ErrorCodes::KeyNotFound, - str::stream() - << "Failed to resume collection scan: the recordId from " - "which we are " - << "attempting to resume no longer exists in the collection. " - << "recordId: " << recordIdToSeek); - } - } } + + return PlanStage::NEED_TIME; } if (_lastSeenId.isNull() && _params.direction == CollectionScanParams::FORWARD && @@ -371,24 +354,16 @@ PlanStage::StageState CollectionScan::returnIfMatches(WorkingSetMember* member, // In the future, we could change seekNear() to always return a record after minRecord in the // direction of the scan. However, tailable scans depend on the current behavior in order to // mark their position for resuming the tailable scan later on. - if (beforeStartOfRange(_params, *member)) { - _workingSet->free(memberID); - return PlanStage::NEED_TIME; - } - - if (!Filter::passes(member, _filter)) { - _workingSet->free(memberID); - if (_params.shouldReturnEofOnFilterMismatch) { - _commonStats.isEOF = true; - return PlanStage::IS_EOF; + if (!beforeStartOfRange(_params, *member) && Filter::passes(member, _filter)) { + if (_params.stopApplyingFilterAfterFirstMatch) { + _filter = nullptr; } + *out = memberID; + return PlanStage::ADVANCED; + } else { + _workingSet->free(memberID); return PlanStage::NEED_TIME; } - if (_params.stopApplyingFilterAfterFirstMatch) { - _filter = nullptr; - } - *out = memberID; - return PlanStage::ADVANCED; } bool CollectionScan::isEOF() { @@ -431,7 +406,9 @@ void CollectionScan::doReattachToOperationContext() { unique_ptr<PlanStageStats> CollectionScan::getStats() { // Add a BSON representation of the filter to the stats tree, if there is one. if (nullptr != _filter) { - _commonStats.filter = _filter->serialize(); + BSONObjBuilder bob; + _filter->serialize(&bob); + _commonStats.filter = bob.obj(); } unique_ptr<PlanStageStats> ret = std::make_unique<PlanStageStats>(_commonStats, STAGE_COLLSCAN); diff --git a/src/mongo/db/exec/collection_scan_common.h b/src/mongo/db/exec/collection_scan_common.h index 8aecb6750fc..ba5559a4491 100644 --- a/src/mongo/db/exec/collection_scan_common.h +++ b/src/mongo/db/exec/collection_scan_common.h @@ -42,16 +42,12 @@ struct CollectionScanParams { }; enum class ScanBoundInclusion { - kExcludeBothStartAndEndRecords = 0b00, - kIncludeStartRecordOnly = 0b01, - kIncludeEndRecordOnly = 0b10, - kIncludeBothStartAndEndRecords = 0b11, + kExcludeBothStartAndEndRecords, + kIncludeStartRecordOnly, + kIncludeEndRecordOnly, + kIncludeBothStartAndEndRecords, }; - static ScanBoundInclusion makeInclusion(bool startInclusive, bool endInclusive) { - return ScanBoundInclusion(int(startInclusive) | (int(endInclusive) << 1)); - } - // If present, this parameter sets the start point of a forward scan or the end point of a // reverse scan. A forward scan will start scanning at the document with the lowest RecordId // greater than or equal to minRecord. A reverse scan will stop and return EOF on the first @@ -115,10 +111,6 @@ struct CollectionScanParams { // Whether or not to wait for oplog visibility on oplog collection scans. bool shouldWaitForOplogVisibility = false; - - // Whether or not to return EOF and stop further scanning once MatchExpression evaluates to - // false. Can only be set to true if the MatchExpression is present. - bool shouldReturnEofOnFilterMismatch = false; }; } // namespace mongo diff --git a/src/mongo/db/exec/delete_stage.cpp b/src/mongo/db/exec/delete_stage.cpp index 581ef2ef294..83941b91c4e 100644 --- a/src/mongo/db/exec/delete_stage.cpp +++ b/src/mongo/db/exec/delete_stage.cpp @@ -178,38 +178,23 @@ PlanStage::StageState DeleteStage::doWork(WorkingSetID* out) { bool writeToOrphan = false; if (!_params->isExplain && !_params->fromMigrate) { - try { - const auto action = _preWriteFilter.computeAction(member->doc.value()); - if (action == write_stage_common::PreWriteFilter::Action::kSkip) { - LOGV2_DEBUG( - 5983201, - 3, - "Skipping delete operation to orphan document to prevent a wrong change " - "stream event", - "namespace"_attr = collection()->ns(), - "record"_attr = member->doc.value()); - return PlanStage::NEED_TIME; - } else if (action == write_stage_common::PreWriteFilter::Action::kWriteAsFromMigrate) { - LOGV2_DEBUG(6184700, - 3, - "Marking delete operation to orphan document with the fromMigrate flag " - "to prevent a wrong change stream event", - "namespace"_attr = collection()->ns(), - "record"_attr = member->doc.value()); - writeToOrphan = true; - } - } catch (const ExceptionFor<ErrorCodes::StaleConfig>& ex) { - if (ex->getVersionReceived() == ChunkVersion::IGNORED() && - ex->getCriticalSectionSignal()) { - // If ChunkVersion is IGNORED and we encountered a critical section, then yield, - // wait for the critical section to finish and then we'll resume the write from the - // point we had left. We do this to prevent large multi-writes from repeatedly - // failing due to StaleConfig and exhausting the mongos retry attempts. - planExecutorShardingCriticalSectionFuture(opCtx()) = ex->getCriticalSectionSignal(); - memberFreer.dismiss(); // Keep this member around so we can retry deleting it. - return prepareToRetryWSM(id, out); - } - throw; + const auto action = _preWriteFilter.computeAction(member->doc.value()); + if (action == write_stage_common::PreWriteFilter::Action::kSkip) { + LOGV2_DEBUG(5983201, + 3, + "Skipping delete operation to orphan document to prevent a wrong change " + "stream event", + "namespace"_attr = collection()->ns(), + "record"_attr = member->doc.value()); + return PlanStage::NEED_TIME; + } else if (action == write_stage_common::PreWriteFilter::Action::kWriteAsFromMigrate) { + LOGV2_DEBUG(6184700, + 3, + "Marking delete operation to orphan document with the fromMigrate flag " + "to prevent a wrong change stream event", + "namespace"_attr = collection()->ns(), + "record"_attr = member->doc.value()); + writeToOrphan = true; } } @@ -250,18 +235,6 @@ PlanStage::StageState DeleteStage::doWork(WorkingSetID* out) { } catch (const WriteConflictException&) { memberFreer.dismiss(); // Keep this member around so we can retry deleting it. return prepareToRetryWSM(id, out); - } catch (const ExceptionFor<ErrorCodes::StaleConfig>& ex) { - if (ex->getVersionReceived() == ChunkVersion::IGNORED() && - ex->getCriticalSectionSignal()) { - // If ChunkVersion is IGNORED and we encountered a critical section, then yield, - // wait for the critical section to finish and then we'll resume the write from the - // point we had left. We do this to prevent large multi-writes from repeatedly - // failing due to StaleConfig and exhausting the mongos retry attempts. - planExecutorShardingCriticalSectionFuture(opCtx()) = ex->getCriticalSectionSignal(); - memberFreer.dismiss(); // Keep this member around so we can retry deleting it. - return prepareToRetryWSM(id, out); - } - throw; } } _specificStats.docsDeleted += _params->numStatsForDoc ? _params->numStatsForDoc(bsonObjDoc) : 1; diff --git a/src/mongo/db/exec/document_value/document.cpp b/src/mongo/db/exec/document_value/document.cpp index 7172370e4c3..dd833b3c28f 100644 --- a/src/mongo/db/exec/document_value/document.cpp +++ b/src/mongo/db/exec/document_value/document.cpp @@ -88,11 +88,8 @@ const StringDataSet Document::allMetadataFieldNames{Document::metaFieldTextScore Document::metaFieldGeoNearPoint, Document::metaFieldSearchScore, Document::metaFieldSearchHighlights, - Document::metaFieldSearchSortValues, Document::metaFieldIndexKey, - Document::metaFieldSearchScoreDetails, - Document::metaFieldVectorSearchScore, - Document::metaFieldSearchSequenceToken}; + Document::metaFieldSearchScoreDetails}; DocumentStorageIterator::DocumentStorageIterator(DocumentStorage* storage, BSONObjIterator bsonIt) : _bsonIt(std::move(bsonIt)), @@ -133,7 +130,7 @@ bool DocumentStorageIterator::shouldSkipDeleted() { // If we strip the metadata see if a field name matches the known list. All metadata fields // start with '$' so optimize for a quick bailout. - if (_storage->bsonHasMetadata() && !fieldName.empty() && fieldName[0] == '$' && + if (_storage->stripMetadata() && fieldName[0] == '$' && Document::allMetadataFieldNames.contains(fieldName)) { return true; } @@ -346,8 +343,8 @@ void DocumentStorage::reserveFields(size_t expectedFields) { } intrusive_ptr<DocumentStorage> DocumentStorage::clone() const { - auto out = make_intrusive<DocumentStorage>( - _bson, _bsonHasMetadata, _modified, _numBytesFromBSONInCache); + auto out = + make_intrusive<DocumentStorage>(_bson, _stripMetadata, _modified, _numBytesFromBSONInCache); if (_cache) { // Make a copy of the buffer with the fields. @@ -376,7 +373,6 @@ intrusive_ptr<DocumentStorage> DocumentStorage::clone() const { out->_haveLazyLoadedMetadata = _haveLazyLoadedMetadata; out->_metadataFields = _metadataFields; - out->_snapshottedSize = _snapshottedSize; return out; } @@ -393,12 +389,11 @@ DocumentStorage::~DocumentStorage() { } } -void DocumentStorage::reset(const BSONObj& bson, bool bsonHasMetadata) { +void DocumentStorage::reset(const BSONObj& bson, bool stripMetadata) { _bson = bson; _numBytesFromBSONInCache = 0; - _bsonHasMetadata = bsonHasMetadata; + _stripMetadata = stripMetadata; _modified = false; - _snapshottedSize = 0; // Clean cache. for (auto it = iteratorCacheOnly(); !it.atEnd(); it.advance()) { @@ -414,22 +409,10 @@ void DocumentStorage::reset(const BSONObj& bson, bool bsonHasMetadata) { _metadataFields = DocumentMetadataFields{}; } -Document DocumentStorage::shred() const { - MutableDocument md; - // Iterate raw bson if possible. This avoids caching all of the values in a doc that might get - // thrown away. - if (!isModified() && !bsonHasMetadata()) { - for (const auto& elem : _bson) { - md[elem.fieldNameStringData()] = Value(elem).shred(); - } - } else { - for (DocumentStorageIterator it = iterator(); !it.atEnd(); it.advance()) { - const auto& valueElem = it.get(); - md[it.fieldName()] = valueElem.val.shred(); - } +void DocumentStorage::fillCache() const { + for (DocumentStorageIterator it = iterator(); !it.atEnd(); it.advance()) { + it->val.fillCache(); } - md.setMetadata(DocumentMetadataFields(metadata())); - return md.freeze(); } void DocumentStorage::loadLazyMetadata() const { @@ -437,13 +420,11 @@ void DocumentStorage::loadLazyMetadata() const { return; } - bool oldModified = _metadataFields.isModified(); - BSONObjIterator it(_bson); while (it.more()) { BSONElement elem(it.next()); auto fieldName = elem.fieldNameStringData(); - if (!fieldName.empty() && fieldName[0] == '$') { + if (fieldName[0] == '$') { if (fieldName == Document::metaFieldTextScore) { _metadataFields.setTextScore(elem.Double()); } else if (fieldName == Document::metaFieldSearchScore) { @@ -479,17 +460,10 @@ void DocumentStorage::loadLazyMetadata() const { _metadataFields.setIndexKey(elem.Obj()); } else if (fieldName == Document::metaFieldSearchScoreDetails) { _metadataFields.setSearchScoreDetails(elem.Obj()); - } else if (fieldName == Document::metaFieldSearchSortValues) { - _metadataFields.setSearchSortValues(elem.Obj()); - } else if (fieldName == Document::metaFieldVectorSearchScore) { - _metadataFields.setVectorSearchScore(elem.Double()); - } else if (fieldName == Document::metaFieldSearchSequenceToken) { - _metadataFields.setSearchSequenceToken(Value(elem)); } } } - _metadataFields.setModified(oldModified); _haveLazyLoadedMetadata = true; } @@ -539,11 +513,22 @@ void Document::toBson(BSONObjBuilder* builder, size_t recursionLevel) const { } } +BSONObj Document::toBson() const { + if (!storage().isModified() && !storage().stripMetadata()) { + return storage().bsonObj(); + } + + BSONObjBuilder bb; + toBson(&bb); + return bb.obj(); +} + boost::optional<BSONObj> Document::toBsonIfTriviallyConvertible() const { - if (isTriviallyConvertible()) { + if (!storage().isModified() && !storage().stripMetadata()) { return storage().bsonObj(); + } else { + return boost::none; } - return boost::none; } constexpr StringData Document::metaFieldTextScore; @@ -554,44 +539,35 @@ constexpr StringData Document::metaFieldGeoNearPoint; constexpr StringData Document::metaFieldSearchScore; constexpr StringData Document::metaFieldSearchHighlights; constexpr StringData Document::metaFieldSearchScoreDetails; -constexpr StringData Document::metaFieldSearchSortValues; -constexpr StringData Document::metaFieldVectorSearchScore; -void Document::toBsonWithMetaData(BSONObjBuilder* builder) const { - toBson(builder); +BSONObj Document::toBsonWithMetaData() const { + BSONObjBuilder bb; + toBson(&bb); if (!metadata()) { - return; + return bb.obj(); } if (metadata().hasTextScore()) - builder->append(metaFieldTextScore, metadata().getTextScore()); + bb.append(metaFieldTextScore, metadata().getTextScore()); if (metadata().hasRandVal()) - builder->append(metaFieldRandVal, metadata().getRandVal()); + bb.append(metaFieldRandVal, metadata().getRandVal()); if (metadata().hasSortKey()) - builder->append(metaFieldSortKey, - DocumentMetadataFields::serializeSortKey(metadata().isSingleElementKey(), - metadata().getSortKey())); + bb.append(metaFieldSortKey, + DocumentMetadataFields::serializeSortKey(metadata().isSingleElementKey(), + metadata().getSortKey())); if (metadata().hasGeoNearDistance()) - builder->append(metaFieldGeoNearDistance, metadata().getGeoNearDistance()); + bb.append(metaFieldGeoNearDistance, metadata().getGeoNearDistance()); if (metadata().hasGeoNearPoint()) - metadata().getGeoNearPoint().addToBsonObj(builder, metaFieldGeoNearPoint); + metadata().getGeoNearPoint().addToBsonObj(&bb, metaFieldGeoNearPoint); if (metadata().hasSearchScore()) - builder->append(metaFieldSearchScore, metadata().getSearchScore()); + bb.append(metaFieldSearchScore, metadata().getSearchScore()); if (metadata().hasSearchHighlights()) - metadata().getSearchHighlights().addToBsonObj(builder, metaFieldSearchHighlights); + metadata().getSearchHighlights().addToBsonObj(&bb, metaFieldSearchHighlights); if (metadata().hasIndexKey()) - builder->append(metaFieldIndexKey, metadata().getIndexKey()); + bb.append(metaFieldIndexKey, metadata().getIndexKey()); if (metadata().hasSearchScoreDetails()) - builder->append(metaFieldSearchScoreDetails, metadata().getSearchScoreDetails()); - if (metadata().hasSearchSortValues()) { - builder->append(metaFieldSearchSortValues, metadata().getSearchSortValues()); - } - if (metadata().hasSearchSequenceToken()) { - metadata().getSearchSequenceToken().addToBsonObj(builder, metaFieldSearchSequenceToken); - } - if (metadata().hasVectorSearchScore()) { - builder->append(metaFieldVectorSearchScore, metadata().getVectorSearchScore()); - } + bb.append(metaFieldSearchScoreDetails, metadata().getSearchScoreDetails()); + return bb.obj(); } Document Document::fromBsonWithMetaData(const BSONObj& bson) { @@ -728,17 +704,31 @@ const Value Document::getNestedField(const FieldPath& path, vector<Position>* po return getNestedFieldHelper(*this, path, positions, 0); } -size_t Document::getApproximateSize() const { - return sizeof(Document) + storage().snapshottedApproximateSize(); +size_t Document::getApproximateSizeWithoutBackingBSON() const { + size_t size = sizeof(Document); + if (!_storage) + return size; + + size += sizeof(DocumentStorage); + size += storage().allocatedBytes(); + + for (auto it = storage().iteratorCacheOnly(); !it.atEnd(); it.advance()) { + size += it->val.getApproximateSize(); + size -= sizeof(Value); // already accounted for above + } + + // The metadata also occupies space in the document storage that's pre-allocated. + size += storage().getMetadataApproximateSize(); + + return size; } -size_t Document::getCurrentApproximateSize() const { - return sizeof(Document) + storage().currentApproximateSize(); +size_t Document::getApproximateSize() const { + return getApproximateSizeWithoutBackingBSON() + storage().bsonObjSize(); } size_t Document::memUsageForSorter() const { - return storage().currentApproximateSize() - storage().bsonObjSize() + - storage().nonCachedBsonObjSize(); + return getApproximateSizeWithoutBackingBSON() + storage().nonCachedBsonObjSize(); } void Document::hash_combine(size_t& seed, diff --git a/src/mongo/db/exec/document_value/document.h b/src/mongo/db/exec/document_value/document.h index 6114aee792d..8fcfb28dd8b 100644 --- a/src/mongo/db/exec/document_value/document.h +++ b/src/mongo/db/exec/document_value/document.h @@ -100,10 +100,7 @@ public: static constexpr StringData metaFieldSearchScore = "$searchScore"_sd; static constexpr StringData metaFieldSearchHighlights = "$searchHighlights"_sd; static constexpr StringData metaFieldSearchScoreDetails = "$searchScoreDetails"_sd; - static constexpr StringData metaFieldSearchSortValues = "$searchSortValues"_sd; static constexpr StringData metaFieldIndexKey = "$indexKey"_sd; - static constexpr StringData metaFieldVectorSearchScore = "$vectorSearchScore"_sd; - static constexpr StringData metaFieldSearchSequenceToken = "$searchSequenceToken"_sd; static const StringDataSet allMetadataFieldNames; @@ -194,8 +191,7 @@ public: /** * Get the approximate size of the Document, plus its underlying storage and sub-values. Returns - * size in bytes. The return value of this function is snapshotted. All subsequent calls of this - * method will return the same value. + * size in bytes. * * Note: Some memory may be shared with other Documents or between fields within a single * Document so this can overestimate usage. @@ -206,11 +202,6 @@ public: size_t getApproximateSize() const; /** - * Same as 'getApproximateSize()', but this method re-computes the size on every call. - */ - size_t getCurrentApproximateSize() const; - - /** * Return the approximate amount of space used by metadata. */ size_t getMetadataApproximateSize() const { @@ -248,10 +239,10 @@ public: } /** - * Returns a cache-only copy of the document with no backing bson. + * Populates the internal cache by recursively walking the underlying BSON. */ - Document shred() const { - return storage().shred(); + void fillCache() const { + storage().fillCache(); } /** Calculate a hash value. @@ -262,38 +253,12 @@ public: void hash_combine(size_t& seed, const StringData::ComparatorInterface* stringComparator) const; /** - * Returns true, if this document is trivially convertible to BSON, meaning the underlying - * storage is already in BSON format and there are no damages. - */ - bool isTriviallyConvertible() const { - return !storage().isModified() && !storage().bsonHasMetadata(); - } - - /** - * Returns true, if this document is trivially convertible to BSON with metadata, meaning the - * underlying storage is already in BSON format and there are no damages. - */ - bool isTriviallyConvertibleWithMetadata() const { - return !storage().isModified() && !storage().isMetadataModified(); - } - - /** * Serializes this document to the BSONObj under construction in 'builder'. Metadata is not * included. Throws a AssertionException if 'recursionLevel' exceeds the maximum allowable * depth. */ void toBson(BSONObjBuilder* builder, size_t recursionLevel = 1) const; - - template <typename BSONTraits = BSONObj::DefaultSizeTrait> - BSONObj toBson() const { - if (isTriviallyConvertible()) { - return storage().bsonObj(); - } - - BSONObjBuilder bb; - toBson(&bb); - return bb.obj<BSONTraits>(); - } + BSONObj toBson() const; /** * Serializes this document iff the conversion is "trivial," meaning that the underlying storage @@ -307,18 +272,7 @@ public: /** * Like the 'toBson()' method, but includes metadata as top-level fields. */ - void toBsonWithMetaData(BSONObjBuilder* builder) const; - - template <typename BSONTraits = BSONObj::DefaultSizeTrait> - BSONObj toBsonWithMetaData() const { - if (isTriviallyConvertibleWithMetadata()) { - return storage().bsonObj(); - } - - BSONObjBuilder bb; - toBsonWithMetaData(&bb); - return bb.obj<BSONTraits>(); - } + BSONObj toBsonWithMetaData() const; /** * Like Document(BSONObj) but treats top-level fields with special names as metadata. @@ -416,6 +370,12 @@ private: getNestedFieldNonCachingHelper(const FieldPath& dottedField, size_t level) const; boost::intrusive_ptr<const DocumentStorage> _storage; + + /** + * Returns the approximate size of this `Document` instance without considering the size of its + * backing BSON object. + */ + size_t getApproximateSizeWithoutBackingBSON() const; }; // @@ -551,11 +511,13 @@ public: } /** - * Replace the current base Document with the BSON object. Setting 'bsonHasMetadata' to true - * signals that the BSON object contains metadata fields. + * Replace the current base Document with bson. + * + * The paramater 'stripMetadata' controls whether we strip the metadata fields from the + * underlying bson when converting the document object back to bson. */ - void reset(const BSONObj& bson, bool bsonHasMetadata) { - storage().reset(bson, bsonHasMetadata); + void reset(const BSONObj& bson, bool stripMetadata) { + storage().reset(bson, stripMetadata); } /** Add the given field to the Document. @@ -692,7 +654,6 @@ public: * TODO: there are some optimizations that may make sense at freeze time. */ Document freeze() { - resetSnapshottedApproximateSize(); // This essentially moves _storage into a new Document by way of temp. Document ret; boost::intrusive_ptr<const DocumentStorage> temp(storagePtr(), /*inc_ref_count=*/false); @@ -711,12 +672,8 @@ public: * Note that unlike freeze(), this indicates intention to continue * modifying this document. The returned Document will not observe * future changes to this MutableDocument. - * - * Note that the computed snapshotted approximate size of the Document - * is not preserved across calls. */ Document peek() { - resetSnapshottedApproximateSize(); return Document(storagePtr()); } @@ -738,13 +695,13 @@ public: storage().makeOwned(); } - /** - * Creates a new document storage with the BSON object. Setting 'bsonHasMetadata' to true - * signals that the BSON object contains metadata fields (the complete list is in - * Document::allMetadataFieldNames). + /** Create a new document storage with the BSON object. + * + * The optional paramater 'stripMetadata' controls whether we strip the metadata fields (the + * complete list is in Document::allMetadataFieldNames). */ - DocumentStorage& newStorageWithBson(const BSONObj& bson, bool bsonHasMetadata) { - reset(make_intrusive<DocumentStorage>(bson, bsonHasMetadata, false, 0)); + DocumentStorage& newStorageWithBson(const BSONObj& bson, bool stripMetadata) { + reset(make_intrusive<DocumentStorage>(bson, stripMetadata, false, 0)); return const_cast<DocumentStorage&>(*storagePtr()); } @@ -782,19 +739,12 @@ private: MutableValue getNestedFieldHelper(const FieldPath& dottedField, size_t level); MutableValue getNestedFieldHelper(const std::vector<Position>& positions, size_t level); - // this should only be called by storage methods and peek/freeze/resetsnapshottedApproximateSize + // this should only be called by storage methods and peek/freeze const DocumentStorage* storagePtr() const { dassert(!_storage || typeid(*_storage) == typeid(const DocumentStorage)); return static_cast<const DocumentStorage*>(_storage); } - void resetSnapshottedApproximateSize() { - auto mutableStorage = const_cast<DocumentStorage*>(storagePtr()); - if (mutableStorage) { - mutableStorage->resetSnapshottedApproximateSize(); - } - } - // These are both const to prevent modifications bypassing storage() method. // They always point to NULL or an object with dynamic type DocumentStorage. const RefCountable* _storageHolder; // Only used in constructors and destructor diff --git a/src/mongo/db/exec/document_value/document_internal.h b/src/mongo/db/exec/document_value/document_internal.h index d7fb3b337d6..1387ca908b4 100644 --- a/src/mongo/db/exec/document_value/document_internal.h +++ b/src/mongo/db/exec/document_value/document_internal.h @@ -359,11 +359,11 @@ public: /** * Construct a storage from the BSON. The BSON is lazily processed as fields are requested from - * the document. If we know that the BSON contains metadata fields we can set the - * 'bsonHasMetadata' flag to true. + * the document. If we know that the BSON does not contain any metadata fields we can set the + * 'stripMetadata' flag to false that will speed up the field iteration. */ DocumentStorage(const BSONObj& bson, - bool bsonHasMetadata, + bool stripMetadata, bool modified, uint32_t numBytesFromBSONInCache) : _cache(nullptr), @@ -373,17 +373,17 @@ public: _hashTabMask(0), _bson(bson), _numBytesFromBSONInCache(numBytesFromBSONInCache), - _bsonHasMetadata(bsonHasMetadata), + _stripMetadata(stripMetadata), _modified(modified) {} ~DocumentStorage(); - void reset(const BSONObj& bson, bool bsonHasMetadata); + void reset(const BSONObj& bson, bool stripMetadata); /** - * Returns a cache-only copy of the document with no backing bson. + * Populates the cache by recursively walking the underlying BSON. */ - Document shred() const; + void fillCache() const; static const DocumentStorage& emptyDoc() { return kEmptyDoc; @@ -551,7 +551,7 @@ public: * WorkingSetMember. */ const DocumentMetadataFields& metadata() const { - if (_bsonHasMetadata) { + if (_stripMetadata) { loadLazyMetadata(); } return _metadataFields; @@ -589,8 +589,8 @@ public: return _firstElement ? _firstElement->plusBytes(_usedBytes) : nullptr; } - auto bsonHasMetadata() const { - return _bsonHasMetadata; + auto stripMetadata() const { + return _stripMetadata; } Position constructInCache(const BSONElement& elem); @@ -599,37 +599,10 @@ public: return _modified; } - auto isMetadataModified() const { - return _metadataFields.isModified(); - } - auto bsonObj() const { return _bson; } - size_t currentApproximateSize() const { - size_t size = sizeof(DocumentStorage) + allocatedBytes() + getMetadataApproximateSize() + - bsonObjSize(); - - for (auto it = iteratorCacheOnly(); !it.atEnd(); it.advance()) { - size += it->val.getApproximateSize() - sizeof(Value); - } - - return size; - } - - size_t snapshottedApproximateSize() const { - if (_snapshottedSize == 0) { - const_cast<DocumentStorage*>(this)->_snapshottedSize = currentApproximateSize(); - } - - return _snapshottedSize; - } - - void resetSnapshottedApproximateSize() { - _snapshottedSize = 0; - } - private: /// Returns the position of the named field in the cache or Position() template <typename T> @@ -712,23 +685,22 @@ private: // whole backing BSON, but only the portion of backing BSON that's not already in the cache. uint32_t _numBytesFromBSONInCache = 0; - // Tracks whether or not the metadata has been lazy-loaded from the backing '_bson' object. If - // so, then no attempt will be made to load the metadata again, even if the metadata has been - // released by a call to 'releaseMetadata()'. + // If '_stripMetadata' is true, tracks whether or not the metadata has been lazy-loaded from the + // backing '_bson' object. If so, then no attempt will be made to load the metadata again, even + // if the metadata has been released by a call to 'releaseMetadata()'. mutable bool _haveLazyLoadedMetadata = false; mutable DocumentMetadataFields _metadataFields; - // True if this storage was constructed from BSON with metadata. Serializing this object using - // the 'toBson()' method will omit (strip) the metadata fields. - bool _bsonHasMetadata{false}; + // The storage constructed from a BSON value may contain metadata. When we process the BSON we + // have to move the metadata to the MetadataFields object. If we know that the BSON does not + // have any metadata we can set _stripMetadata to false that will speed up the iteration. + bool _stripMetadata{false}; // This flag is set to true anytime the storage returns a mutable field. It is used to optimize // a conversion to BSON; i.e. if there are not any modifications we can directly return _bson. bool _modified{false}; - size_t _snapshottedSize{0}; - // Defined in document.cpp static const DocumentStorage kEmptyDoc; diff --git a/src/mongo/db/exec/document_value/document_metadata_fields.cpp b/src/mongo/db/exec/document_value/document_metadata_fields.cpp index 27f64ef7286..90e15ef5c2a 100644 --- a/src/mongo/db/exec/document_value/document_metadata_fields.cpp +++ b/src/mongo/db/exec/document_value/document_metadata_fields.cpp @@ -46,7 +46,6 @@ DocumentMetadataFields::DocumentMetadataFields(const DocumentMetadataFields& oth DocumentMetadataFields& DocumentMetadataFields::operator=(const DocumentMetadataFields& other) { _holder = other._holder ? std::make_unique<MetadataHolder>(*other._holder) : nullptr; - _modified = true; return *this; } @@ -55,7 +54,6 @@ DocumentMetadataFields::DocumentMetadataFields(DocumentMetadataFields&& other) DocumentMetadataFields& DocumentMetadataFields::operator=(DocumentMetadataFields&& other) { _holder = std::move(other._holder); - _modified = true; return *this; } @@ -87,21 +85,12 @@ void DocumentMetadataFields::mergeWith(const DocumentMetadataFields& other) { if (!hasSearchScoreDetails() && other.hasSearchScoreDetails()) { setSearchScoreDetails(other.getSearchScoreDetails()); } - if (!hasSearchSequenceToken() && other.hasSearchSequenceToken()) { - setSearchSequenceToken(other.getSearchSequenceToken()); - } if (!hasTimeseriesBucketMinTime() && other.hasTimeseriesBucketMinTime()) { setTimeseriesBucketMinTime(other.getTimeseriesBucketMinTime()); } if (!hasTimeseriesBucketMaxTime() && other.hasTimeseriesBucketMaxTime()) { setTimeseriesBucketMaxTime(other.getTimeseriesBucketMaxTime()); } - if (!hasSearchSortValues() && other.hasSearchSortValues()) { - setSearchSortValues(other.getSearchSortValues()); - } - if (!hasVectorSearchScore() && other.hasVectorSearchScore()) { - setVectorSearchScore(other.getVectorSearchScore()); - } } void DocumentMetadataFields::copyFrom(const DocumentMetadataFields& other) { @@ -132,21 +121,12 @@ void DocumentMetadataFields::copyFrom(const DocumentMetadataFields& other) { if (other.hasSearchScoreDetails()) { setSearchScoreDetails(other.getSearchScoreDetails()); } - if (other.hasSearchSequenceToken()) { - setSearchSequenceToken(other.getSearchSequenceToken()); - } if (other.hasTimeseriesBucketMinTime()) { setTimeseriesBucketMinTime(other.getTimeseriesBucketMinTime()); } if (other.hasTimeseriesBucketMaxTime()) { setTimeseriesBucketMaxTime(other.getTimeseriesBucketMaxTime()); } - if (other.hasSearchSortValues()) { - setSearchSortValues(other.getSearchSortValues()); - } - if (other.hasVectorSearchScore()) { - setVectorSearchScore(other.getVectorSearchScore()); - } } size_t DocumentMetadataFields::getApproximateSize() const { @@ -168,8 +148,7 @@ size_t DocumentMetadataFields::getApproximateSize() const { size -= sizeof(_holder->searchHighlights); size += _holder->indexKey.objsize(); size += _holder->searchScoreDetails.objsize(); - size += _holder->searchSortValues.objsize(); - size -= sizeof(_holder->searchSequenceToken); + return size; } @@ -217,10 +196,6 @@ void DocumentMetadataFields::serializeForSorter(BufBuilder& buf) const { buf.appendNum(static_cast<char>(MetaType::kSearchScoreDetails + 1)); getSearchScoreDetails().appendSelfToBufBuilder(buf); } - if (hasSearchSequenceToken()) { - buf.appendNum(static_cast<char>(MetaType::kSearchSequenceToken + 1)); - getSearchSequenceToken().serializeForSorter(buf); - } if (hasTimeseriesBucketMinTime()) { buf.appendNum(static_cast<char>(MetaType::kTimeseriesBucketMinTime + 1)); buf.appendNum(getTimeseriesBucketMinTime().toMillisSinceEpoch()); @@ -229,14 +204,6 @@ void DocumentMetadataFields::serializeForSorter(BufBuilder& buf) const { buf.appendNum(static_cast<char>(MetaType::kTimeseriesBucketMaxTime + 1)); buf.appendNum(getTimeseriesBucketMaxTime().toMillisSinceEpoch()); } - if (hasSearchSortValues()) { - buf.appendNum(static_cast<char>(MetaType::kSearchSortValues + 1)); - getSearchSortValues().appendSelfToBufBuilder(buf); - } - if (hasVectorSearchScore()) { - buf.appendNum(static_cast<char>(MetaType::kVectorSearchScore + 1)); - buf.appendNum(getVectorSearchScore()); - } buf.appendNum(static_cast<char>(0)); } @@ -269,19 +236,9 @@ void DocumentMetadataFields::deserializeForSorter(BufReader& buf, DocumentMetada out->setSearchScoreDetails( BSONObj::deserializeForSorter(buf, BSONObj::SorterDeserializeSettings())); } else if (marker == static_cast<char>(MetaType::kTimeseriesBucketMinTime) + 1) { - out->setTimeseriesBucketMinTime( - Date_t::fromMillisSinceEpoch(buf.read<LittleEndian<long long>>())); + out->setTimeseriesBucketMinTime(Date_t::fromMillisSinceEpoch(buf.read<long long>())); } else if (marker == static_cast<char>(MetaType::kTimeseriesBucketMaxTime) + 1) { - out->setTimeseriesBucketMaxTime( - Date_t::fromMillisSinceEpoch(buf.read<LittleEndian<long long>>())); - } else if (marker == static_cast<char>(MetaType::kSearchSortValues) + 1) { - out->setSearchSortValues( - BSONObj::deserializeForSorter(buf, BSONObj::SorterDeserializeSettings())); - } else if (marker == static_cast<char>(MetaType::kVectorSearchScore) + 1) { - out->setVectorSearchScore(buf.read<LittleEndian<double>>()); - } else if (marker == static_cast<char>(MetaType::kSearchSequenceToken) + 1) { - out->setSearchSequenceToken( - Value::deserializeForSorter(buf, Value::SorterDeserializeSettings())); + out->setTimeseriesBucketMaxTime(Date_t::fromMillisSinceEpoch(buf.read<long long>())); } else { uasserted(28744, "Unrecognized marker, unable to deserialize buffer"); } @@ -341,12 +298,6 @@ const char* DocumentMetadataFields::typeNameToDebugString(DocumentMetadataFields return "timeseries bucket min time"; case DocumentMetadataFields::kTimeseriesBucketMaxTime: return "timeseries bucket max time"; - case DocumentMetadataFields::kSearchSortValues: - return "$search sort values"; - case DocumentMetadataFields::kSearchSequenceToken: - return "$search sequence token"; - case DocumentMetadataFields::kVectorSearchScore: - return "$vectorSearch distance"; default: MONGO_UNREACHABLE; } diff --git a/src/mongo/db/exec/document_value/document_metadata_fields.h b/src/mongo/db/exec/document_value/document_metadata_fields.h index 6759675c7ea..12932c29686 100644 --- a/src/mongo/db/exec/document_value/document_metadata_fields.h +++ b/src/mongo/db/exec/document_value/document_metadata_fields.h @@ -67,9 +67,6 @@ public: kSearchScoreDetails, kTimeseriesBucketMinTime, kTimeseriesBucketMaxTime, - kSearchSortValues, - kVectorSearchScore, - kSearchSequenceToken, // New fields must be added before the kNumFields sentinel. kNumFields @@ -151,7 +148,11 @@ public: } void setTextScore(double score) { - _setCommon(MetaType::kTextScore); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kTextScore); _holder->textScore = score; } @@ -165,7 +166,11 @@ public: } void setRandVal(double val) { - _setCommon(MetaType::kRandVal); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kRandVal); _holder->randVal = val; } @@ -179,7 +184,11 @@ public: } void setSortKey(Value sortKey, bool isSingleElementKey) { - _setCommon(MetaType::kSortKey); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kSortKey); _holder->isSingleElementKey = isSingleElementKey; _holder->sortKey = std::move(sortKey); } @@ -198,7 +207,11 @@ public: } void setGeoNearDistance(double dist) { - _setCommon(MetaType::kGeoNearDist); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kGeoNearDist); _holder->geoNearDistance = dist; } @@ -212,7 +225,11 @@ public: } void setGeoNearPoint(Value point) { - _setCommon(MetaType::kGeoNearPoint); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kGeoNearPoint); _holder->geoNearPoint = std::move(point); } @@ -226,7 +243,11 @@ public: } void setSearchScore(double score) { - _setCommon(MetaType::kSearchScore); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kSearchScore); _holder->searchScore = score; } @@ -240,7 +261,11 @@ public: } void setSearchHighlights(Value highlights) { - _setCommon(MetaType::kSearchHighlights); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kSearchHighlights); _holder->searchHighlights = highlights; } @@ -254,7 +279,11 @@ public: } void setIndexKey(BSONObj indexKey) { - _setCommon(MetaType::kIndexKey); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kIndexKey); _holder->indexKey = indexKey.getOwned(); } @@ -268,7 +297,11 @@ public: } void setRecordId(RecordId rid) { - _setCommon(MetaType::kRecordId); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + + _holder->metaFields.set(MetaType::kRecordId); _holder->recordId = rid; } @@ -282,7 +315,10 @@ public: } void setSearchScoreDetails(BSONObj details) { - _setCommon(MetaType::kSearchScoreDetails); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + _holder->metaFields.set(MetaType::kSearchScoreDetails); _holder->searchScoreDetails = details.getOwned(); } @@ -291,14 +327,15 @@ public: } Date_t getTimeseriesBucketMinTime() const { - tassert(6850100, - "Document must have timeseries bucket min time metadata field set", - hasTimeseriesBucketMinTime()); + invariant(hasTimeseriesBucketMinTime()); return _holder->timeseriesBucketMinTime; } void setTimeseriesBucketMinTime(Date_t time) { - _setCommon(MetaType::kTimeseriesBucketMinTime); + if (!_holder) { + _holder = std::make_unique<MetadataHolder>(); + } + _holder->metaFields.set(MetaType::kTimeseriesBucketMinTime); _holder->timeseriesBucketMinTime = time; } @@ -307,83 +344,20 @@ public: } Date_t getTimeseriesBucketMaxTime() const { - tassert(6850101, - "Document must have timeseries bucket max time metadata field set", - hasTimeseriesBucketMaxTime()); + invariant(hasTimeseriesBucketMaxTime()); return _holder->timeseriesBucketMaxTime; } void setTimeseriesBucketMaxTime(Date_t time) { - _setCommon(MetaType::kTimeseriesBucketMaxTime); - _holder->timeseriesBucketMaxTime = time; - } - - bool hasSearchSortValues() const { - return _holder && _holder->metaFields.test(MetaType::kSearchSortValues); - } - - BSONObj getSearchSortValues() const { - tassert(7320401, "Document must have $searchSortValues set", hasSearchSortValues()); - return _holder->searchSortValues; - } - - void setSearchSortValues(BSONObj vals) { - _setCommon(MetaType::kSearchSortValues); - _holder->searchSortValues = vals.getOwned(); - } - - bool hasVectorSearchScore() const { - return _holder && _holder->metaFields.test(MetaType::kVectorSearchScore); - } - - double getVectorSearchScore() const { - tassert(7828400, "vectorSearchScore must be present in metadata", hasVectorSearchScore()); - return _holder->vectorSearchScore; - } - - void setVectorSearchScore(double vectorSearchScore) { - _setCommon(MetaType::kVectorSearchScore); - _holder->vectorSearchScore = vectorSearchScore; - } - - bool hasSearchSequenceToken() const { - return _holder && _holder->metaFields.test(MetaType::kSearchSequenceToken); - } - - Value getSearchSequenceToken() const { - invariant(hasSearchSequenceToken()); - return _holder->searchSequenceToken; - } - - void setSearchSequenceToken(Value details) { - _setCommon(MetaType::kSearchSequenceToken); - _holder->searchSequenceToken = details; - } - - void serializeForSorter(BufBuilder& buf) const; - - bool isModified() const { - return _modified; - } - - /** - * Sets the 'modified' flag to the given value. Necessary for implementing a lazy load - * optimization for the contained mutable 'DocumentMetadataFields' instance inside the - * 'Document' class. - */ - void setModified(bool newValue) { - _modified = newValue; - } - -private: - inline void _setCommon(MetaType mt) { if (!_holder) { _holder = std::make_unique<MetadataHolder>(); } - _holder->metaFields.set(mt); - _modified = true; + _holder->metaFields.set(MetaType::kTimeseriesBucketMaxTime); + _holder->timeseriesBucketMaxTime = time; } + void serializeForSorter(BufBuilder& buf) const; +private: // A simple data struct housing all possible metadata fields. struct MetadataHolder { std::bitset<MetaType::kNumFields> metaFields; @@ -405,18 +379,10 @@ private: BSONObj searchScoreDetails; Date_t timeseriesBucketMinTime; Date_t timeseriesBucketMaxTime; - BSONObj searchSortValues; - double vectorSearchScore{0.0}; - Value searchSequenceToken; }; // Null until the first setter is called, at which point a MetadataHolder struct is allocated. std::unique_ptr<MetadataHolder> _holder; - - // This flag is set to true anytime a 'DocumentMetadataFields' instance is modified. It is used - // to optimize document conversion to BSON with metadata; i.e. if there are no modifications we - // can directly return the underlying BSON. - bool _modified{false}; }; using QueryMetadataBitSet = std::bitset<DocumentMetadataFields::MetaType::kNumFields>; diff --git a/src/mongo/db/exec/document_value/document_metadata_fields_test.cpp b/src/mongo/db/exec/document_value/document_metadata_fields_test.cpp index 23ab2277c96..5515009b2bd 100644 --- a/src/mongo/db/exec/document_value/document_metadata_fields_test.cpp +++ b/src/mongo/db/exec/document_value/document_metadata_fields_test.cpp @@ -34,7 +34,6 @@ #include "mongo/db/exec/document_value/document_metadata_fields.h" #include "mongo/db/exec/document_value/document_value_test_util.h" #include "mongo/unittest/bson_test_util.h" -#include "mongo/unittest/death_test.h" #include "mongo/unittest/unittest.h" namespace mongo { @@ -51,8 +50,6 @@ TEST(DocumentMetadataFieldsTest, AllMetadataRoundtripsThroughSerialization) { metadata.setIndexKey(BSON("b" << 1)); metadata.setSearchScoreDetails(BSON("scoreDetails" << "foo")); - metadata.setSearchSortValues(BSON("a" << 1)); - metadata.setVectorSearchScore(7.6); BufBuilder builder; metadata.serializeForSorter(builder); @@ -72,8 +69,6 @@ TEST(DocumentMetadataFieldsTest, AllMetadataRoundtripsThroughSerialization) { ASSERT_BSONOBJ_EQ(deserialized.getSearchScoreDetails(), BSON("scoreDetails" << "foo")); - ASSERT_BSONOBJ_EQ(deserialized.getSearchSortValues(), BSON("a" << 1)); - ASSERT_EQ(deserialized.getVectorSearchScore(), 7.6); } TEST(DocumentMetadataFieldsTest, HasMethodsReturnFalseForEmptyMetadata) { @@ -88,8 +83,6 @@ TEST(DocumentMetadataFieldsTest, HasMethodsReturnFalseForEmptyMetadata) { ASSERT_FALSE(metadata.hasSearchHighlights()); ASSERT_FALSE(metadata.hasIndexKey()); ASSERT_FALSE(metadata.hasSearchScoreDetails()); - ASSERT_FALSE(metadata.hasSearchSortValues()); - ASSERT_FALSE(metadata.hasVectorSearchScore()); } TEST(DocumentMetadataFieldsTest, HasMethodsReturnTrueForInitializedMetadata) { @@ -132,14 +125,6 @@ TEST(DocumentMetadataFieldsTest, HasMethodsReturnTrueForInitializedMetadata) { metadata.setSearchScoreDetails(BSON("scoreDetails" << "foo")); ASSERT_TRUE(metadata.hasSearchScoreDetails()); - - ASSERT_FALSE(metadata.hasSearchSortValues()); - metadata.setSearchSortValues(BSON("a" << 1)); - ASSERT_TRUE(metadata.hasSearchSortValues()); - - ASSERT_FALSE(metadata.hasVectorSearchScore()); - metadata.setVectorSearchScore(7.6); - ASSERT_TRUE(metadata.hasVectorSearchScore()); } TEST(DocumentMetadataFieldsTest, MoveConstructor) { @@ -154,8 +139,6 @@ TEST(DocumentMetadataFieldsTest, MoveConstructor) { metadata.setIndexKey(BSON("b" << 1)); metadata.setSearchScoreDetails(BSON("scoreDetails" << "foo")); - metadata.setSearchSortValues(BSON("a" << 1)); - metadata.setVectorSearchScore(7.6); DocumentMetadataFields moveConstructed(std::move(metadata)); ASSERT_TRUE(moveConstructed); @@ -171,8 +154,6 @@ TEST(DocumentMetadataFieldsTest, MoveConstructor) { ASSERT_BSONOBJ_EQ(moveConstructed.getSearchScoreDetails(), BSON("scoreDetails" << "foo")); - ASSERT_BSONOBJ_EQ(moveConstructed.getSearchSortValues(), BSON("a" << 1)); - ASSERT_EQ(moveConstructed.getVectorSearchScore(), 7.6); ASSERT_FALSE(metadata); // NOLINT(bugprone-use-after-move) } @@ -189,8 +170,6 @@ TEST(DocumentMetadataFieldsTest, MoveAssignmentOperator) { metadata.setIndexKey(BSON("b" << 1)); metadata.setSearchScoreDetails(BSON("scoreDetails" << "foo")); - metadata.setSearchSortValues(BSON("a" << 1)); - metadata.setVectorSearchScore(7.6); DocumentMetadataFields moveAssigned; moveAssigned.setTextScore(12.3); @@ -209,8 +188,6 @@ TEST(DocumentMetadataFieldsTest, MoveAssignmentOperator) { ASSERT_BSONOBJ_EQ(moveAssigned.getSearchScoreDetails(), BSON("scoreDetails" << "foo")); - ASSERT_BSONOBJ_EQ(moveAssigned.getSearchSortValues(), BSON("a" << 1)); - ASSERT_EQ(moveAssigned.getVectorSearchScore(), 7.6); ASSERT_FALSE(metadata); // NOLINT(bugprone-use-after-move) } @@ -264,8 +241,6 @@ TEST(DocumentMetadataFieldsTest, MergeWithOnlyCopiesMetadataThatDestinationDoesN ASSERT_FALSE(destination.hasSearchHighlights()); ASSERT_FALSE(destination.hasIndexKey()); ASSERT_FALSE(destination.hasSearchScoreDetails()); - ASSERT_FALSE(destination.hasSearchSortValues()); - ASSERT_FALSE(destination.hasVectorSearchScore()); } TEST(DocumentMetadataFieldsTest, CopyFromCopiesAllMetadataThatSourceHas) { @@ -291,173 +266,6 @@ TEST(DocumentMetadataFieldsTest, CopyFromCopiesAllMetadataThatSourceHas) { ASSERT_FALSE(destination.hasSearchHighlights()); ASSERT_FALSE(destination.hasIndexKey()); ASSERT_FALSE(destination.hasSearchScoreDetails()); - ASSERT_FALSE(destination.hasSearchSortValues()); - ASSERT_FALSE(destination.hasVectorSearchScore()); -} - -TEST(DocumentMetadataFieldsTest, GetTimeseriesBucketMinTimeExists) { - DocumentMetadataFields source; - Date_t time; - source.setTimeseriesBucketMinTime(time); - ASSERT_EQ(source.getTimeseriesBucketMinTime(), time); -} - -TEST(DocumentMetadataFieldsTest, GetTimeseriesBucketMaxTimeExists) { - DocumentMetadataFields source; - Date_t time; - source.setTimeseriesBucketMaxTime(time); - ASSERT_EQ(source.getTimeseriesBucketMaxTime(), time); -} - -TEST(DocumentMetadataFieldsTest, MetadataIsMarkedModifiedOnSetMetadataField) { - // Test setting metadata fields directly. - - auto testFieldSetter = [](std::function<void(DocumentMetadataFields&)> invokeSetter) { - DocumentMetadataFields metadata; - ASSERT_FALSE(metadata.isModified()); - invokeSetter(metadata); - ASSERT_TRUE(metadata.isModified()); - }; - - testFieldSetter([](DocumentMetadataFields& md) { md.setTextScore(10.0); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setRandVal(20.0); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setSortKey(Value(30), true); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setGeoNearDistance(40.0); }); - testFieldSetter( - [](DocumentMetadataFields& md) { md.setGeoNearPoint(Value{BSON_ARRAY(1 << 2)}); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setSearchScore(50.0); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setSearchHighlights(Value{"foo"_sd}); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setIndexKey(BSON("b" << 1)); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setRecordId(RecordId{6}); }); - testFieldSetter([](DocumentMetadataFields& md) { - md.setSearchScoreDetails(BSON("scoreDetails" - << "foo")); - }); - testFieldSetter([](DocumentMetadataFields& md) { md.setTimeseriesBucketMinTime(Date_t()); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setTimeseriesBucketMaxTime(Date_t()); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setSearchSortValues(BSON("a" << 1)); }); - testFieldSetter([](DocumentMetadataFields& md) { md.setVectorSearchScore(60.0); }); -} - -TEST(DocumentMetadataFieldsTest, MetadataIsConstructedUnmodified) { - // We consider new instances as unmodified for all constructors (default, copy, move) even when - // the original metadata has the 'modified' flag set. - - // Testing the default constructor. - DocumentMetadataFields metadata1; - ASSERT_FALSE(metadata1.isModified()); - metadata1.setTextScore(10.0); - ASSERT_TRUE(metadata1.isModified()); - - // Testing the copy-constructor. - DocumentMetadataFields metadata2(metadata1); - ASSERT_FALSE(metadata2.isModified()); - - // Testing the move-constructor. - DocumentMetadataFields metadata3(std::move(metadata1)); - ASSERT_FALSE(metadata3.isModified()); -} - -TEST(DocumentMetadataFieldsTest, CopyAssignmentIsModification) { - // We consider copy-assignment as modification even when the instances are equal and the copied - // metadata does not have the 'modified' flag set. - - DocumentMetadataFields metadata1; - ASSERT_FALSE(metadata1.isModified()); - - DocumentMetadataFields metadata2; - ASSERT_FALSE(metadata2.isModified()); - - // Testing copy-assignment to empty object (metadata2 == metadata1). - metadata2 = metadata1; - ASSERT_TRUE(metadata2.isModified()); - - // Testing copy-assignment in a more common case (metadata1 is empty, metadata2 is not empty). - metadata2.setTextScore(10.0); - metadata2.setModified(false); - ASSERT_FALSE(metadata2.isModified()); - metadata1 = metadata2; - ASSERT_TRUE(metadata1.isModified()); - ASSERT_EQ(metadata2.getTextScore(), metadata1.getTextScore()); -} - -TEST(DocumentMetadataFieldsTest, MoveAssignmentIsModification) { - // We consider move-assignment as modification even when the instances are equal and the moved - // metadata does not have the 'modified' flag set. - - DocumentMetadataFields metadata1; - ASSERT_FALSE(metadata1.isModified()); - - DocumentMetadataFields metadata2; - ASSERT_FALSE(metadata2.isModified()); - - // Testing move-assignment to empty object (metadata2 == metadata1). - metadata2 = std::move(metadata1); - ASSERT_TRUE(metadata2.isModified()); - - // Testing move-assignment in a more common case (metadata3 is empty, metadata2 is not empty). - metadata2.setTextScore(10.0); - metadata2.setModified(false); - ASSERT_FALSE(metadata2.isModified()); - - DocumentMetadataFields metadata3; - ASSERT_FALSE(metadata3.isModified()); - - metadata3 = std::move(metadata2); - ASSERT_TRUE(metadata3.isModified()); - ASSERT_EQ(10.0, metadata3.getTextScore()); -} - -TEST(DocumentMetadataFieldsTest, MetadataIsMarkedModifiedOnCopyFrom) { - DocumentMetadataFields metadata1; - metadata1.setRandVal(20.0); - ASSERT_TRUE(metadata1.isModified()); - - // Testing 'setModified(false)'. - metadata1.setModified(false); - ASSERT_FALSE(metadata1.isModified()); - - // Calling 'copyFrom(metadata1)' modifies metadata2 even when metadata2 == metadata1 and - // metadata1 is not marked as modified. - DocumentMetadataFields metadata2(metadata1); - ASSERT_FALSE(metadata2.isModified()); - metadata2.copyFrom(metadata1); - ASSERT_TRUE(metadata2.isModified()); -} - -TEST(DocumentMetadataFieldsTest, MetadataIsMarkedModifiedOnMergeWith) { - DocumentMetadataFields metadata1; - metadata1.setRandVal(20.0); - ASSERT_TRUE(metadata1.isModified()); - - metadata1.setModified(false); - ASSERT_FALSE(metadata1.isModified()); - - // Calling 'mergeWith(metadata1)' modifies metadata2 only when metadata1 has fields not set in - // metadata1. - DocumentMetadataFields metadata2(metadata1); - ASSERT_FALSE(metadata2.isModified()); - metadata2.mergeWith(metadata1); - ASSERT_FALSE(metadata2.isModified()); - - DocumentMetadataFields metadata3; - ASSERT_FALSE(metadata3.isModified()); - metadata3.mergeWith(metadata2); - ASSERT_TRUE(metadata3.isModified()); -} - -DEATH_TEST_REGEX(DocumentMetadataFieldsTest, - GetTimeseriesBucketMinTimeDoesntExist, - "Tripwire assertion.*6850100") { - DocumentMetadataFields source; - source.getTimeseriesBucketMinTime(); -} - -DEATH_TEST_REGEX(DocumentMetadataFieldsTest, - GetTimeseriesBucketMaxTimeDoesntExist, - "Tripwire assertion.*6850101") { - DocumentMetadataFields source; - source.getTimeseriesBucketMaxTime(); } } // namespace mongo diff --git a/src/mongo/db/exec/document_value/document_value_test.cpp b/src/mongo/db/exec/document_value/document_value_test.cpp index ca1123a7555..421da707001 100644 --- a/src/mongo/db/exec/document_value/document_value_test.cpp +++ b/src/mongo/db/exec/document_value/document_value_test.cpp @@ -355,89 +355,6 @@ TEST(DocumentGetFieldNonCaching, TraverseArray) { checkArrayTagIsReturned(); } -TEST(DocumentSize, ApproximateSizeIsSnapshotted) { - const auto rawBson = BSON("field" - << "value"); - const Document document{rawBson}; - const auto noCacheSize = document.getApproximateSize(); - - // Force the cache construction, making the total size of the 'Document' bigger. - // 'getApproximateSize()' must still return the same value. - document["field"]; - const auto fullCacheSizeSnapshot = document.getApproximateSize(); - const auto fullCacheSizeCurrent = document.getCurrentApproximateSize(); - ASSERT_EQ(noCacheSize, fullCacheSizeSnapshot); - ASSERT_LT(noCacheSize, fullCacheSizeCurrent); -} - -TEST(DocumentSize, ApproximateSizeDuringBuildIsUpdated) { - MutableDocument builder; - builder.addField("a1", Value(1)); - builder.addField("a2", mongo::Value(2)); - builder.addField("a3", mongo::Value(3)); - auto middleBuildSize = builder.getApproximateSize(); - - builder.addField("a4", Value(4)); - builder.addField("a5", mongo::Value(5)); - builder.addField("a6", mongo::Value(6)); - auto peekSize = builder.peek().getApproximateSize(); - - builder.addField("a7", Value(7)); - builder.addField("a8", mongo::Value(8)); - builder.addField("a9", mongo::Value(9)); - auto beforeFreezeSize = builder.getApproximateSize(); - - Document result = builder.freeze(); - auto frozenSize = result.getApproximateSize(); - - ASSERT_LT(middleBuildSize, peekSize); - ASSERT_LT(peekSize, beforeFreezeSize); - ASSERT_EQ(beforeFreezeSize, frozenSize); -} - -TEST(ShredDocument, OutputHasNoBackingBSON) { - BSONObj bson = - BSON("a" << 1 << "subObj" << BSON("a" << 1) << "subArray" << BSON_ARRAY(BSON("a" << 1))); - auto original = fromBson(bson); - auto originalSize = original.getApproximateSize(); - - auto shredded = original.shred(); - auto originalSizeAfterShredding = original.getApproximateSize(); - // Fields in the original doc shouldn't be cached since it was raw bson - ASSERT_EQ(originalSize, originalSizeAfterShredding); - - // BSON is more compact than ValueElement - auto shreddedSize = shredded.getApproximateSize(); - ASSERT_LT(originalSize, shreddedSize); - - // Accessing a field shouldn't change the size since all fields are already cached. - shredded["a"]; - ASSERT_EQ(shredded.getCurrentApproximateSize(), shreddedSize); -} - -TEST(ShredDocument, HandlesModifiedDocuments) { - BSONObj bson = BSON("a" << 1 << "subObj" << BSON("a" << 1)); - Document original = fromBson(bson); - MutableDocument md(original); - md["b"] = Value(2); - md["subObj"]["b"] = Value(2); - Document shredded = md.freeze().shred(); - - ASSERT(!shredded["b"].missing()); - ASSERT(!shredded["subObj"]["b"].missing()); -} - -TEST(ShredDocument, HandlesMetadata) { - BSONObj bson = BSON("a" << 1 << "subObj" << BSON("a" << 1)); - Document original = fromBson(bson); - MutableDocument md(original); - DocumentMetadataFields meta; - meta.setSearchScore(6); - md.setMetadata(std::move(meta)); - Document shredded = md.freeze().shred(); - ASSERT_EQ(6, shredded.metadata().getSearchScore()); -} - /** Add Document fields. */ class AddField { public: @@ -788,22 +705,6 @@ public: BSONObjBuilder objBuilder; BSONArrayBuilder arrBuilder; }; - -TEST(DocumentTest, ToBsonSizeTraits) { - constexpr size_t longStringLength = 9 * 1024 * 1024; - static_assert(longStringLength <= BSONObjMaxInternalSize && - 2 * longStringLength > BSONObjMaxInternalSize && - 2 * longStringLength <= BufferMaxSize); - std::string longString(longStringLength, 'A'); - MutableDocument md; - md.addField("a", Value(longString)); - ASSERT_DOES_NOT_THROW(md.peek().toBson()); - md.addField("b", Value(longString)); - ASSERT_THROWS_CODE(md.peek().toBson(), DBException, ErrorCodes::BSONObjectTooLarge); - ASSERT_THROWS_CODE( - md.peek().toBson<BSONObj::DefaultSizeTrait>(), DBException, ErrorCodes::BSONObjectTooLarge); - ASSERT_DOES_NOT_THROW(md.peek().toBson<BSONObj::LargeSizeTrait>()); -} } // namespace Document namespace MetaFields { @@ -930,15 +831,6 @@ TEST(MetaFields, FromBsonWithMetadataAcceptsIndexKeyMetadata) { ASSERT_BSONOBJ_EQ(bsonWithoutMetadata, BSON("a" << 1)); } -TEST(MetaFields, FromBsonWithMetadataHandlesEmptyFieldName) { - auto bson = BSON("" << 1 << "$indexKey" << BSON("b" << 1)); - auto doc = Document::fromBsonWithMetaData(bson); - ASSERT_TRUE(doc.metadata().hasIndexKey()); - ASSERT_BSONOBJ_EQ(doc.metadata().getIndexKey(), BSON("b" << 1)); - auto bsonWithoutMetadata = doc.toBson(); - ASSERT_BSONOBJ_EQ(bsonWithoutMetadata, BSON("" << 1)); -} - TEST(MetaFields, CopyMetadataFromCopiesAllMetadata) { Document source = Document::fromBsonWithMetaData( BSON("a" << 1 << "$textScore" << 9.9 << "b" << 1 << "$randVal" << 42.0 << "c" << 1 @@ -948,8 +840,7 @@ TEST(MetaFields, CopyMetadataFromCopiesAllMetadata) { << "foo" << "h" << 1 << "$indexKey" << BSON("y" << 1) << "$searchScoreDetails" << BSON("scoreDetails" - << "foo") - << "$searchSortValues" << BSON("a" << 1) << "$vectorSearchScore" << 6.7)); + << "foo"))); MutableDocument destination{}; destination.copyMetaDataFrom(source); @@ -966,8 +857,6 @@ TEST(MetaFields, CopyMetadataFromCopiesAllMetadata) { ASSERT_BSONOBJ_EQ(result.metadata().getSearchScoreDetails(), BSON("scoreDetails" << "foo")); - ASSERT_BSONOBJ_EQ(result.metadata().getSearchSortValues(), BSON("a" << 1)); - ASSERT_EQ(result.metadata().getVectorSearchScore(), 6.7); } class SerializationTest : public unittest::Test { @@ -988,8 +877,6 @@ protected: ASSERT_EQ(output.metadata().hasSearchScore(), input.metadata().hasSearchScore()); ASSERT_EQ(output.metadata().hasSearchHighlights(), input.metadata().hasSearchHighlights()); ASSERT_EQ(output.metadata().hasIndexKey(), input.metadata().hasIndexKey()); - ASSERT_EQ(output.metadata().hasVectorSearchScore(), - input.metadata().hasVectorSearchScore()); if (input.metadata().hasTextScore()) { ASSERT_EQ(output.metadata().getTextScore(), input.metadata().getTextScore()); } @@ -1010,10 +897,6 @@ protected: ASSERT_BSONOBJ_EQ(output.metadata().getSearchScoreDetails(), input.metadata().getSearchScoreDetails()); } - if (input.metadata().hasVectorSearchScore()) { - ASSERT_EQ(output.metadata().getVectorSearchScore(), - input.metadata().getVectorSearchScore()); - } ASSERT(output.toBson().binaryEqual(input.toBson())); } @@ -1028,7 +911,6 @@ TEST_F(SerializationTest, MetaSerializationNoVals) { << "def"_sd)); docBuilder.metadata().setSearchScoreDetails(BSON("scoreDetails" << "foo")); - docBuilder.metadata().setVectorSearchScore(40.0); assertRoundTrips(docBuilder.freeze()); } @@ -1043,7 +925,6 @@ TEST_F(SerializationTest, MetaSerializationWithVals) { docBuilder.metadata().setIndexKey(BSON("key" << 42)); docBuilder.metadata().setSearchScoreDetails(BSON("scoreDetails" << "foo")); - docBuilder.metadata().setVectorSearchScore(40.0); assertRoundTrips(docBuilder.freeze()); } @@ -1066,8 +947,6 @@ TEST(MetaFields, ToAndFromBson) { << "def"_sd)); docBuilder.metadata().setSearchScoreDetails(BSON("scoreDetails" << "foo")); - docBuilder.metadata().setSearchSortValues(BSON("a" << 42)); - docBuilder.metadata().setVectorSearchScore(40.0); Document doc = docBuilder.freeze(); BSONObj obj = doc.toBsonWithMetaData(); ASSERT_EQ(10.0, obj[Document::metaFieldTextScore].Double()); @@ -1079,8 +958,6 @@ TEST(MetaFields, ToAndFromBson) { ASSERT_BSONOBJ_EQ(obj[Document::metaFieldSearchScoreDetails].Obj(), BSON("scoreDetails" << "foo")); - ASSERT_BSONOBJ_EQ(BSON("a" << 42), obj[Document::metaFieldSearchSortValues].Obj()); - ASSERT_EQ(40.0, obj[Document::metaFieldVectorSearchScore].Double()); Document fromBson = Document::fromBsonWithMetaData(obj); ASSERT_TRUE(fromBson.metadata().hasTextScore()); ASSERT_TRUE(fromBson.metadata().hasRandVal()); @@ -1089,110 +966,6 @@ TEST(MetaFields, ToAndFromBson) { ASSERT_BSONOBJ_EQ(BSON("scoreDetails" << "foo"), fromBson.metadata().getSearchScoreDetails()); - ASSERT_BSONOBJ_EQ(BSON("a" << 42), fromBson.metadata().getSearchSortValues()); - ASSERT_EQ(40.0, fromBson.metadata().getVectorSearchScore()); -} - -TEST(MetaFields, ToAndFromBsonTrivialConvertibility) { - Value sortKey{Document{{"token"_sd, "SOMENCODEDATA"_sd}}}; - // Create a document with a backing BSONObj and separate metadata. - auto origObjNoMetadata = BSON("a" << 42); - ASSERT_FALSE(origObjNoMetadata.hasField(Document::metaFieldSortKey)); - - MutableDocument docBuilder; - docBuilder.reset(origObjNoMetadata, false); - docBuilder.metadata().setSortKey(sortKey, true); - Document docWithSeparateBsonAndMetadata = docBuilder.freeze(); - - BSONObj origObjWithMetadata = docWithSeparateBsonAndMetadata.toBsonWithMetaData(); - ASSERT_TRUE(origObjWithMetadata.hasField(Document::metaFieldSortKey)); - Document restoredDocWithMetadata = Document::fromBsonWithMetaData(origObjWithMetadata); - ASSERT_DOCUMENT_EQ(docWithSeparateBsonAndMetadata, restoredDocWithMetadata); - - // Test the 'isTriviallyConvertible()' function. - // The original document is trivially convertible without metadata because the metadata was - // added to the document separately from the backing BSON object. - ASSERT_TRUE(docWithSeparateBsonAndMetadata.isTriviallyConvertible()); - // The original document is NOT trivially convertible with metadata because the metadata was - // added to the document and does not exist in the BSONObj. - ASSERT_FALSE(docWithSeparateBsonAndMetadata.isTriviallyConvertibleWithMetadata()); - // The restored document is trivially convertible with metadata because the underlying BSONObj - // contains the metadata serialized from the original document. - ASSERT_TRUE(restoredDocWithMetadata.isTriviallyConvertibleWithMetadata()); - // The restored document is NOT trivially convertible without metadata because the metadata - // fields need to be stripped from the underlying BSONObj. - ASSERT_FALSE(restoredDocWithMetadata.isTriviallyConvertible()); - - // Test that the conversion with metadata 'origObjWithMetadata' -> 'restoredDocWithMetadata' -> - // 'restoredObjWithMetadata' is trivial because the backing BSON already contains metadata and - // neither the metadata nor the non-metadata fields have been modified. - BSONObj restoredObjWithMetadata = restoredDocWithMetadata.toBsonWithMetaData(); - ASSERT_TRUE(restoredObjWithMetadata.hasField(Document::metaFieldSortKey)); - // Test that 'restoredObjWithMetadata' is referring to the exact same memory location as - // 'origObjWithMetadata', i.e. both objdata() and objsize() match. - ASSERT_EQ(origObjWithMetadata.objdata(), restoredObjWithMetadata.objdata()); - ASSERT_EQ(origObjWithMetadata.objsize(), restoredObjWithMetadata.objsize()); - - // Test that the conversion without metadata 'origObjWithMetadata' -> 'restoredDocWithMetadata' - // -> 'strippedRestoredObj' is NOT trivial because the backing BSON has metadata that must be - // omitted during serialization. - BSONObj strippedRestoredObj = restoredDocWithMetadata.toBson(); - ASSERT_FALSE(strippedRestoredObj.hasField(Document::metaFieldSortKey)); - // 'restoredDocWithMetadata' is trivially convertible with metadata and converting it to BSON - // without metadata will return a new BSON object. - ASSERT_TRUE(origObjNoMetadata.binaryEqual(strippedRestoredObj)); - ASSERT_NE(origObjNoMetadata.objdata(), strippedRestoredObj.objdata()); - - // Test that the conversion without metadata 'origObjNoMetadata' -> - // 'docWithSeparateBsonAndMetadata' -> 'restoredObjNoMetadata' is trivial because - // 'origObjNoMetadata' does not contain any metadata. - BSONObj restoredObjNoMetadata = docWithSeparateBsonAndMetadata.toBson(); - ASSERT_FALSE(restoredObjNoMetadata.hasField(Document::metaFieldSortKey)); - // Test that 'restoredObjNoMetadata' is referring to the exact same memory location as - // 'origObjNoMetadata', i.e. both objdata() and objsize() match. - ASSERT_EQ(origObjNoMetadata.objdata(), restoredObjNoMetadata.objdata()); - ASSERT_EQ(origObjNoMetadata.objsize(), restoredObjNoMetadata.objsize()); -} - -TEST(MetaFields, TrivialConvertibilityBsonWithoutMetadata) { - // Test that an unmodified document without metadata is trivially convertible to BSON with and - // without metadata. - auto bsonWithoutMetadata = BSON("a" << 42); - Document doc(bsonWithoutMetadata); - ASSERT_TRUE(doc.isTriviallyConvertible()); - ASSERT_TRUE(doc.isTriviallyConvertibleWithMetadata()); -} - -TEST(MetaFields, TrivialConvertibilityNoBson) { - // A Document created with no backing BSON is not trivially convertible. - auto docNoBson = Document{{"a", 42}}; - ASSERT_FALSE(docNoBson.isTriviallyConvertible()); - ASSERT_FALSE(docNoBson.isTriviallyConvertibleWithMetadata()); - - // An empty Document is trivially convertible, since the default BSONObj is also empty. - auto emptyDoc = Document{}; - ASSERT_TRUE(emptyDoc.isTriviallyConvertible()); - ASSERT_TRUE(emptyDoc.isTriviallyConvertibleWithMetadata()); -} - -TEST(MetaFields, TrivialConvertibilityModified) { - // Modifying a document with a backing BSON renders it not trivially convertible. - MutableDocument mutDocModified(Document(BSON("a" << 42))); - mutDocModified.addField("b", Value(43)); - auto modifiedDoc = mutDocModified.freeze(); - ASSERT_FALSE(modifiedDoc.isTriviallyConvertible()); - ASSERT_FALSE(modifiedDoc.isTriviallyConvertibleWithMetadata()); -} - -TEST(MetaFields, TrivialConvertibilityMetadataModified) { - // Modifying the metadata of a document with a backing BSON renders it not trivially convertible - // with metadata. - MutableDocument mutDocModifiedMd( - Document::fromBsonWithMetaData(BSON(Document::metaFieldTextScore << 10.0))); - mutDocModifiedMd.metadata().setRandVal(20.0); - auto modifiedMdDoc = mutDocModifiedMd.freeze(); - ASSERT_FALSE(modifiedMdDoc.isTriviallyConvertible()); - ASSERT_FALSE(modifiedMdDoc.isTriviallyConvertibleWithMetadata()); } TEST(MetaFields, MetaFieldsIncludedInDocumentApproximateSize) { @@ -1210,10 +983,8 @@ TEST(MetaFields, MetaFieldsIncludedInDocumentApproximateSize) { const size_t bigMetadataDocSize = doc2.getApproximateSize(); ASSERT_GT(bigMetadataDocSize, smallMetadataDocSize); - // Do a sanity check on the amount of space taken by metadata in document 2. Note that the size - // of certain data types may vary on different build variants, so we cannot assert on the exact - // size. - ASSERT_LT(doc2.getMetadataApproximateSize(), 400U); + // Do a sanity check on the amount of space taken by metadata in document 2. + ASSERT_LT(doc2.getMetadataApproximateSize(), 300U); Document emptyDoc; ASSERT_LT(emptyDoc.getMetadataApproximateSize(), 100U); diff --git a/src/mongo/db/exec/document_value/document_value_test_util.h b/src/mongo/db/exec/document_value/document_value_test_util.h index 7b88c9688fa..b6959a7d17f 100644 --- a/src/mongo/db/exec/document_value/document_value_test_util.h +++ b/src/mongo/db/exec/document_value/document_value_test_util.h @@ -59,13 +59,6 @@ #define _ASSERT_DOCVAL_COMPARISON(NAME, a, b) \ ::mongo::unittest::assertComparison_##NAME(__FILE__, __LINE__, #a, #b, a, b) -// TODO SERVER-87736 make these not say "AUTO". -// These are backport-special macros, adapted from the "AUTO" version on more recent branches. The -// automatic functionality doesn't exist on this branch. But the assertions should still pass. -#define ASSERT_VALUE_EQ_AUTO(expected, val) ASSERT_EQ(expected, val.toString()) -#define ASSERT_DOCUMENT_EQ_AUTO(expected, actual) \ - ASSERT_BSONOBJ_EQ(fromjson(expected), actual.toBson()) - namespace mongo { namespace unittest { diff --git a/src/mongo/db/exec/document_value/value.cpp b/src/mongo/db/exec/document_value/value.cpp index 616efb2128a..248514180f0 100644 --- a/src/mongo/db/exec/document_value/value.cpp +++ b/src/mongo/db/exec/document_value/value.cpp @@ -45,7 +45,6 @@ #include "mongo/db/query/datetime/date_time_support.h" #include "mongo/platform/decimal128.h" #include "mongo/util/hex.h" -#include "mongo/util/murmur3.h" #include "mongo/util/represent_as.h" #include "mongo/util/str.h" @@ -936,7 +935,7 @@ void Value::hash_combine(size_t& seed, case Code: case Symbol: { StringData sd = getRawData(); - seed = murmur3<sizeof(size_t)>(sd, seed); + MurmurHash3_x86_32(sd.rawData(), sd.size(), seed, &seed); break; } @@ -945,7 +944,7 @@ void Value::hash_combine(size_t& seed, if (stringComparator) { stringComparator->hash_combine(seed, sd); } else { - seed = murmur3<sizeof(size_t)>(sd, seed); + MurmurHash3_x86_32(sd.rawData(), sd.size(), seed, &seed); } break; } @@ -969,14 +968,14 @@ void Value::hash_combine(size_t& seed, case BinData: { StringData sd = getRawData(); - seed = murmur3<sizeof(size_t)>(sd, seed); + MurmurHash3_x86_32(sd.rawData(), sd.size(), seed, &seed); boost::hash_combine(seed, _storage.binDataType()); break; } case RegEx: { StringData sd = getRawData(); - seed = murmur3<sizeof(size_t)>(sd, seed); + MurmurHash3_x86_32(sd.rawData(), sd.size(), seed, &seed); break; } @@ -1254,17 +1253,14 @@ ostream& operator<<(ostream& out, const Value& val) { verify(false); } -Value Value::shred() const { +void Value::fillCache() const { if (isObject()) { - return Value(getDocument().shred()); + getDocument().fillCache(); } else if (isArray()) { - std::vector<Value> values; for (auto&& val : getArray()) { - values.push_back(val.shred()); + val.fillCache(); } - return Value(values); } - return Value(*this); } void Value::serializeForSorter(BufBuilder& buf) const { diff --git a/src/mongo/db/exec/document_value/value.h b/src/mongo/db/exec/document_value/value.h index 62a31f25727..bf54221326c 100644 --- a/src/mongo/db/exec/document_value/value.h +++ b/src/mongo/db/exec/document_value/value.h @@ -344,9 +344,9 @@ public: friend std::ostream& operator<<(std::ostream& out, const Value& v); /** - * Returns a cache-only copy of the value with no backing bson. + * Populates the internal cache by recursively walking the underlying BSON. */ - Value shred() const; + void fillCache() const; void swap(Value& rhs) { _storage.swap(rhs._storage); @@ -430,16 +430,13 @@ public: ImplicitValue(T&& arg) : Value(std::forward<T>(arg)) {} ImplicitValue(std::initializer_list<ImplicitValue> values) : Value(convertToValues(values)) {} - ImplicitValue(std::vector<ImplicitValue> values) : Value(convertToValues(values)) {} - template <typename T> - ImplicitValue(std::vector<T> values) : Value(convertToValues(values)) {} + ImplicitValue(std::vector<int> values) : Value(convertToValues(values)) {} - template <typename T> - static std::vector<Value> convertToValues(const std::vector<T>& vec) { + static std::vector<Value> convertToValues(const std::vector<int>& vec) { std::vector<Value> values; values.reserve(vec.size()); - for_each(vec.begin(), vec.end(), ([&](const T& val) { values.emplace_back(val); })); + for_each(vec.begin(), vec.end(), ([&](const int& val) { values.emplace_back(val); })); return values; } diff --git a/src/mongo/db/exec/document_value/value_comparator_test.cpp b/src/mongo/db/exec/document_value/value_comparator_test.cpp index ac854fdadbe..963a29bc11a 100644 --- a/src/mongo/db/exec/document_value/value_comparator_test.cpp +++ b/src/mongo/db/exec/document_value/value_comparator_test.cpp @@ -312,33 +312,5 @@ TEST(ValueComparatorTest, HashingCodeShouldNotRespectCollation) { ASSERT_NE(comparator.hash(val1), comparator.hash(val2)); } -// This test was originally designed to reproduce SERVER-78126. -TEST(ValueComparatorTest, ArraysDifferingByOneStringShouldHaveDifferentHashes) { - const ValueComparator comparator{}; - const Value val1{std::vector<Value>{Value{std::string{"a"}}, Value{std::string{"x"}}}}; - const Value val2{std::vector<Value>{Value{std::string{"b"}}, Value{std::string{"x"}}}}; - ASSERT_NE(comparator.compare(val1, val2), 0); - ASSERT_NE(comparator.hash(val1), comparator.hash(val2)); -} - -TEST(ValueComparatorTest, ArraysDifferingByOneStringShouldHaveDifferentHashesWithCollation) { - CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); - const ValueComparator comparator{&collator}; - const Value val1{std::vector<Value>{Value{std::string{"abc"}}, Value{std::string{"xyz"}}}}; - const Value val2{std::vector<Value>{Value{std::string{"bcd"}}, Value{std::string{"xyz"}}}}; - ASSERT_NE(comparator.compare(val1, val2), 0); - ASSERT_NE(comparator.hash(val1), comparator.hash(val2)); -} - -TEST(ValueComparatorTest, ObjectsDifferingByOneStringShouldHaveDifferentHashes) { - const ValueComparator comparator{}; - const Value val1( - Document({{"foo"_sd, Value{std::string{"abc"}}}, {"bar"_sd, Value{std::string{"xyz"}}}})); - const Value val2( - Document({{"foo"_sd, Value{std::string{"def"}}}, {"bar"_sd, Value{std::string{"xyz"}}}})); - ASSERT_NE(comparator.compare(val1, val2), 0); - ASSERT_NE(comparator.hash(val1), comparator.hash(val2)); -} - } // namespace } // namespace mongo diff --git a/src/mongo/db/exec/exclusion_projection_executor.cpp b/src/mongo/db/exec/exclusion_projection_executor.cpp index 2061bf4fe93..9823ed1b125 100644 --- a/src/mongo/db/exec/exclusion_projection_executor.cpp +++ b/src/mongo/db/exec/exclusion_projection_executor.cpp @@ -38,15 +38,14 @@ std::pair<BSONObj, bool> ExclusionNode::extractProjectOnFieldAndRename(const Str BSONObjBuilder extractedExclusion; // Check for a projection directly on 'oldName'. For example, {oldName: 0}. - if (auto it = _projectedFieldsSet.find(oldName); it != _projectedFieldsSet.end()) { + if (auto it = _projectedFields.find(oldName); it != _projectedFields.end()) { extractedExclusion.append(newName, false); - _projectedFieldsSet.erase(it); - _projectedFields.remove(std::string(oldName)); + _projectedFields.erase(it); } // Check for a projection on subfields of 'oldName'. For example, {oldName: {a: 0, b: 0}}. if (auto it = _children.find(oldName); it != _children.end()) { - extractedExclusion.append(newName, it->second->serialize(boost::none, {}).toBson()); + extractedExclusion.append(newName, it->second->serialize(boost::none).toBson()); _children.erase(it); } diff --git a/src/mongo/db/exec/exclusion_projection_executor.h b/src/mongo/db/exec/exclusion_projection_executor.h index 37623206723..a9c1fade72d 100644 --- a/src/mongo/db/exec/exclusion_projection_executor.h +++ b/src/mongo/db/exec/exclusion_projection_executor.h @@ -86,9 +86,6 @@ protected: Value transformSkippedValueForOutput(const Value& value) const final { return value; } - bool isIncluded() const final { - return false; - } }; /** @@ -99,12 +96,10 @@ protected: */ class ExclusionProjectionExecutor : public ProjectionExecutor { public: - ExclusionProjectionExecutor( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - ProjectionPolicies policies, - bool allowFastPath = false, - boost::optional<projection_ast::ProjectionPathASTNode> proj = boost::none) - : ProjectionExecutor(expCtx, policies, proj), _root(new ExclusionNode(_policies)) {} + ExclusionProjectionExecutor(const boost::intrusive_ptr<ExpressionContext>& expCtx, + ProjectionPolicies policies, + bool allowFastPath = false) + : ProjectionExecutor(expCtx, policies), _root(new ExclusionNode(_policies)) {} TransformerType getType() const final { return TransformerType::kExclusionProjection; @@ -118,17 +113,16 @@ public: return _root.get(); } - Document serializeTransformation(boost::optional<ExplainOptions::Verbosity> explain, - const SerializationOptions& options = {}) const final { + Document serializeTransformation( + boost::optional<ExplainOptions::Verbosity> explain) const final { MutableDocument output; // The ExclusionNode tree in '_root' will always have a top-level _id node if _id is to be // excluded. If the _id node is not present, then explicitly set {_id: true} to avoid // ambiguity in the expected behavior of the serialized projection. - _root->serialize(explain, &output, options); - auto idFieldName = options.serializeFieldPath("_id"); - if (output.peek()[idFieldName].missing()) { - output.addField(idFieldName, Value{true}); + _root->serialize(explain, &output); + if (output.peek()["_id"].missing()) { + output.addField("_id", Value{true}); } return output.freeze(); } @@ -155,7 +149,7 @@ public: return {DocumentSource::GetModPathsReturn::Type::kAllPaths, {}, {}}; } - OrderedPathSet modifiedPaths; + std::set<std::string> modifiedPaths; _root->reportProjectedPaths(&modifiedPaths); return {DocumentSource::GetModPathsReturn::Type::kFiniteSet, std::move(modifiedPaths), {}}; } diff --git a/src/mongo/db/exec/exclusion_projection_executor_test.cpp b/src/mongo/db/exec/exclusion_projection_executor_test.cpp index c3866ef865f..983c5e1995a 100644 --- a/src/mongo/db/exec/exclusion_projection_executor_test.cpp +++ b/src/mongo/db/exec/exclusion_projection_executor_test.cpp @@ -363,8 +363,7 @@ TEST(ExclusionProjectionExecutionTest, ShouldEvaluateMetaExpressions) { "i: {$meta: 'recordId'}, " "j: {$meta: 'indexKey'}, " "k: {$meta: 'sortKey'}, " - "l: {$meta: 'searchScoreDetails'}, " - "m: {$meta: 'vectorSearchScore'}}")); + "l: {$meta: 'searchScoreDetails'}}")); MutableDocument inputDocBuilder(Document{{"a", 1}, {"b", 2}}); inputDocBuilder.metadata().setTextScore(0.0); @@ -378,7 +377,6 @@ TEST(ExclusionProjectionExecutionTest, ShouldEvaluateMetaExpressions) { inputDocBuilder.metadata().setSortKey(Value{Document{{"bar", 8}}}, true); inputDocBuilder.metadata().setSearchScoreDetails(BSON("scoreDetails" << "foo")); - inputDocBuilder.metadata().setVectorSearchScore(9.0); Document inputDoc = inputDocBuilder.freeze(); auto result = exclusion->applyTransformation(inputDoc); @@ -386,7 +384,7 @@ TEST(ExclusionProjectionExecutionTest, ShouldEvaluateMetaExpressions) { ASSERT_DOCUMENT_EQ(result, Document{fromjson("{b: 2, c: 0.0, d: 1.0, e: 2.0, f: 'foo', g: 3.0, " "h: [4, 5], i: 6, j: {foo: 7}, k: [{bar: 8}]," - "l: {scoreDetails: 'foo'}, m: 9.0}")}); + "l: {scoreDetails: 'foo'}}")}); } TEST(ExclusionProjectionExecutionTest, ShouldAddMetaExpressionsToDependencies) { @@ -400,20 +398,18 @@ TEST(ExclusionProjectionExecutionTest, ShouldAddMetaExpressionsToDependencies) { "i: {$meta: 'recordId'}, " "j: {$meta: 'indexKey'}, " "k: {$meta: 'sortKey'}, " - "l: {$meta: 'searchScoreDetails'}}, " - "m: {$meta: 'vectorSearchScore'}")); + "l: {$meta: 'searchScoreDetails'}}")); DepsTracker deps; exclusion->addDependencies(&deps); ASSERT_EQ(deps.fields.size(), 0UL); - // We do not add the dependencies for searchScore, searchHighlights, searchScoreDetails, or - // distance because those values are not stored in the collection (or in mongod at all). + // We do not add the dependencies for searchScore, searchHighlights, or searchScoreDetails + // because those values are not stored in the collection (or in mongod at all). ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchScore]); ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchHighlights]); ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchScoreDetails]); - ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kVectorSearchScore]); ASSERT_TRUE(deps.metadataDeps()[DocumentMetadataFields::kTextScore]); ASSERT_TRUE(deps.metadataDeps()[DocumentMetadataFields::kRandVal]); diff --git a/src/mongo/db/exec/fetch.cpp b/src/mongo/db/exec/fetch.cpp index 2059faf7d79..9d51dad5ca4 100644 --- a/src/mongo/db/exec/fetch.cpp +++ b/src/mongo/db/exec/fetch.cpp @@ -181,8 +181,10 @@ unique_ptr<PlanStageStats> FetchStage::getStats() { _commonStats.isEOF = isEOF(); // Add a BSON representation of the filter to the stats tree, if there is one. - if (_filter) { - _commonStats.filter = _filter->serialize(); + if (nullptr != _filter) { + BSONObjBuilder bob; + _filter->serialize(&bob); + _commonStats.filter = bob.obj(); } unique_ptr<PlanStageStats> ret = std::make_unique<PlanStageStats>(_commonStats, STAGE_FETCH); diff --git a/src/mongo/db/exec/inclusion_projection_executor.cpp b/src/mongo/db/exec/inclusion_projection_executor.cpp index d06cedf61b6..d7384be8109 100644 --- a/src/mongo/db/exec/inclusion_projection_executor.cpp +++ b/src/mongo/db/exec/inclusion_projection_executor.cpp @@ -67,7 +67,7 @@ void FastPathEligibleInclusionNode::_applyProjections(BSONObj bson, BSONObjBuild const auto bsonElement{it.next()}; const auto fieldName{bsonElement.fieldNameStringData()}; - if (_projectedFieldsSet.find(fieldName) != _projectedFieldsSet.end()) { + if (_projectedFields.find(fieldName) != _projectedFields.end()) { bob->append(bsonElement); --nFieldsNeeded; } else if (auto childIt = _children.find(fieldName); childIt != _children.end()) { @@ -99,55 +99,6 @@ boost::intrusive_ptr<Expression> substituteInExpr(boost::intrusive_ptr<Expressio } return ex; }; - -/** - * Returns a vector of top-level dependencies where each index i in the vector corresponds to the - * dependencies from the ith expression according to 'orderToProcess'. Will return boost::none if - * any expression needs the whole document. - */ -boost::optional<std::vector<OrderedPathSet>> getTopLevelDeps( - const std::vector<std::string>& orderToProcess, - const StringMap<boost::intrusive_ptr<Expression>>& expressions, - const StringMap<std::unique_ptr<ProjectionNode>>& children) { - std::vector<OrderedPathSet> topLevelDeps; - for (const auto& field : orderToProcess) { - DepsTracker deps; - if (auto exprIt = expressions.find(field); exprIt != expressions.end()) { - exprIt->second->addDependencies(&deps); - } else { - // Each expression in orderToProcess should either be in expressions or children. - auto childIt = children.find(field); - tassert(6657000, "Unable to calculate dependencies", childIt != children.end()); - childIt->second->reportDependencies(&deps); - } - - if (deps.needWholeDocument) { - return boost::none; - } - - OrderedPathSet ops{deps.fields.begin(), deps.fields.end()}; - topLevelDeps.push_back( - DepsTracker::simplifyDependencies(ops, DepsTracker::TruncateToRootLevel::yes)); - } - return topLevelDeps; -} - -/** - * Returns whether or not there is an expression in the projection which depends on 'field' other - * than the expression which computes 'field'. For example, given field "a" and projection - * {a: "$b", c: {$sum: ["$a", 5]}}, return true. Given field "a" and projection - * {a: {$sum: ["$a", 5]}, c: "$b"}, return false. 'field' should be a top level path. - */ -bool computedExprDependsOnField(const std::vector<OrderedPathSet>& topLevelDeps, - const std::string& field, - const size_t fieldIndex) { - for (size_t i = 0; i < topLevelDeps.size(); i++) { - if (i != fieldIndex && topLevelDeps[i].count(field) > 0) { - return true; - } - } - return false; -} } // namespace std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInProject( @@ -158,14 +109,8 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInProject( return {BSONObj{}, false}; } - boost::optional<std::vector<OrderedPathSet>> topLevelDeps = - getTopLevelDeps(_orderToProcessAdditionsAndChildren, _expressions, _children); - - // If one of the expression requires the whole document, then we should not extract the - // projection and topLevelDeps will not hold any field names. - if (!topLevelDeps) { - return {BSONObj{}, false}; - } + DepsTracker allDeps; + reportDependencies(&allDeps); // Auxiliary vector with extracted computed projections: <name, expression, replacement // strategy>. If the replacement strategy flag is true, the expression is replaced with a @@ -173,15 +118,19 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInProject( std::vector<std::tuple<StringData, boost::intrusive_ptr<Expression>, bool>> addFieldsExpressions; bool replaceWithProjField = true; - for (size_t i = 0; i < _orderToProcessAdditionsAndChildren.size(); i++) { - auto&& field = _orderToProcessAdditionsAndChildren[i]; - + for (auto&& field : _orderToProcessAdditionsAndChildren) { if (reservedNames.count(field) > 0) { // Do not pushdown computed projection with reserved name. replaceWithProjField = false; continue; } - + if (allDeps.fields.count(field) > 0) { + // Do not extract a computed projection if its name is the same as a dependent field. If + // the extracted $addFields were to be placed before this projection, the dependency + // with the common name would be shadowed by the computed projection. + replaceWithProjField = false; + continue; + } auto expressionIt = _expressions.find(field); if (expressionIt == _expressions.end()) { // After seeing the first dotted path expression we need to replace computed @@ -189,17 +138,13 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInProject( replaceWithProjField = false; continue; } + DepsTracker deps; + expressionIt->second->addDependencies(&deps); + auto topLevelFieldNames = + deps.toProjectionWithoutMetadata(DepsTracker::TruncateToRootLevel::yes) + .getFieldNames<std::set<std::string>>(); + topLevelFieldNames.erase("_id"); - // Do not extract a computed projection if it is computing a value that other fields in the - // same projection depend on. If the extracted $addFields were to be placed before this - // projection, the dependency with the common name would be shadowed by the computed - // projection. - if (computedExprDependsOnField(topLevelDeps.get(), field, i)) { - replaceWithProjField = false; - continue; - } - - const auto& topLevelFieldNames = topLevelDeps.get()[i]; if (topLevelFieldNames.size() == 1 && topLevelFieldNames.count(oldName.toString()) == 1) { // Substitute newName for oldName in the expression. StringMap<std::string> renames; @@ -219,12 +164,11 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInProject( for (const auto& expressionSpec : addFieldsExpressions) { auto&& fieldName = std::get<0>(expressionSpec).toString(); auto oldExpr = std::get<1>(expressionSpec); - oldExpr->serialize().addToBsonObj(&bb, fieldName); + oldExpr->serialize(false).addToBsonObj(&bb, fieldName); if (std::get<2>(expressionSpec)) { // Replace the expression with an inclusion projected field. - auto it = _projectedFields.insert(_projectedFields.end(), fieldName); - _projectedFieldsSet.insert(StringData(*it)); + _projectedFields.insert(fieldName); _expressions.erase(fieldName); // Only computed projections at the beginning of the list were marked to become // projected fields. The new projected field is at the beginning of the @@ -253,40 +197,35 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInAddFields( return {BSONObj{}, false}; } - boost::optional<std::vector<OrderedPathSet>> topLevelDeps = - getTopLevelDeps(_orderToProcessAdditionsAndChildren, _expressions, _children); - - // If one of the expression requires the whole document, then we should not extract the - // projection and topLevelDeps will not hold any field names. - if (!topLevelDeps) { - return {BSONObj{}, false}; - } + DepsTracker allDeps; + reportDependencies(&allDeps); // Auxiliary vector with extracted computed projections: <name, expression>. // To preserve the original fields order, only projections at the beginning of the // _orderToProcessAdditionsAndChildren list can be extracted for pushdown. std::vector<std::pair<StringData, boost::intrusive_ptr<Expression>>> addFieldsExpressions; - for (size_t i = 0; i < _orderToProcessAdditionsAndChildren.size(); i++) { - auto&& field = _orderToProcessAdditionsAndChildren[i]; + for (auto&& field : _orderToProcessAdditionsAndChildren) { // Do not extract for pushdown computed projection with reserved name. if (reservedNames.count(field) > 0) { break; } - - auto expressionIt = _expressions.find(field); - if (expressionIt == _expressions.end()) { + if (allDeps.fields.count(field) > 0) { + // Do not extract a computed projection if its name is the same as a dependent field. If + // the extracted $addFields were to be placed before this $addFields, the dependency + // with the common name would be shadowed by the computed projection. break; } - - // Do not extract a computed projection if it is computing a value that other fields in the - // same projection depend on. If the extracted $addFields were to be placed before this - // projection, the dependency with the common name would be shadowed by the computed - // projection. - if (computedExprDependsOnField(topLevelDeps.get(), field, i)) { + auto expressionIt = _expressions.find(field); + if (expressionIt == _expressions.end()) { break; } + DepsTracker deps; + expressionIt->second->addDependencies(&deps); + auto topLevelFieldNames = + deps.toProjectionWithoutMetadata(DepsTracker::TruncateToRootLevel::yes) + .getFieldNames<std::set<std::string>>(); + topLevelFieldNames.erase("_id"); - auto& topLevelFieldNames = topLevelDeps.get()[i]; if (topLevelFieldNames.size() == 1 && topLevelFieldNames.count(oldName.toString()) == 1) { // Substitute newName for oldName in the expression. StringMap<std::string> renames; @@ -303,7 +242,7 @@ std::pair<BSONObj, bool> InclusionNode::extractComputedProjectionsInAddFields( for (const auto& expressionSpec : addFieldsExpressions) { auto&& fieldName = expressionSpec.first.toString(); auto expr = expressionSpec.second; - expr->serialize().addToBsonObj(&bb, fieldName); + expr->serialize(false).addToBsonObj(&bb, fieldName); // Remove the expression from this inclusion node. _expressions.erase(fieldName); diff --git a/src/mongo/db/exec/inclusion_projection_executor.h b/src/mongo/db/exec/inclusion_projection_executor.h index 7f505f54797..a0429ff924f 100644 --- a/src/mongo/db/exec/inclusion_projection_executor.h +++ b/src/mongo/db/exec/inclusion_projection_executor.h @@ -133,9 +133,6 @@ protected: Value transformSkippedValueForOutput(const Value& value) const final { return Value(); } - bool isIncluded() const final { - return true; - } }; /** @@ -173,24 +170,19 @@ private: */ class InclusionProjectionExecutor : public ProjectionExecutor { public: - InclusionProjectionExecutor( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - ProjectionPolicies policies, - std::unique_ptr<InclusionNode> root, - boost::optional<projection_ast::ProjectionPathASTNode> proj = boost::none) - : ProjectionExecutor(expCtx, policies, proj), _root(std::move(root)) {} - - InclusionProjectionExecutor( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - ProjectionPolicies policies, - bool allowFastPath = false, - boost::optional<projection_ast::ProjectionPathASTNode> proj = boost::none) + InclusionProjectionExecutor(const boost::intrusive_ptr<ExpressionContext>& expCtx, + ProjectionPolicies policies, + std::unique_ptr<InclusionNode> root) + : ProjectionExecutor(expCtx, policies), _root(std::move(root)) {} + + InclusionProjectionExecutor(const boost::intrusive_ptr<ExpressionContext>& expCtx, + ProjectionPolicies policies, + bool allowFastPath = false) : InclusionProjectionExecutor( expCtx, policies, allowFastPath ? std::make_unique<FastPathEligibleInclusionNode>(policies) - : std::make_unique<InclusionNode>(policies), - proj) {} + : std::make_unique<InclusionNode>(policies)) {} TransformerType getType() const final { return TransformerType::kInclusionProjection; @@ -207,17 +199,16 @@ public: /** * Serialize the projection. */ - Document serializeTransformation(boost::optional<ExplainOptions::Verbosity> explain, - const SerializationOptions& options = {}) const final { + Document serializeTransformation( + boost::optional<ExplainOptions::Verbosity> explain) const final { MutableDocument output; // The InclusionNode tree in '_root' will always have a top-level _id node if _id is to be // included. If the _id node is not present, then explicitly set {_id: false} to avoid // ambiguity in the expected behavior of the serialized projection. - _root->serialize(explain, &output, options); - auto idFieldName = options.serializeFieldPath("_id"); - if (output.peek()[idFieldName].missing()) { - output.addField(idFieldName, Value{false}); + _root->serialize(explain, &output); + if (output.peek()["_id"].missing()) { + output.addField("_id", Value{false}); } return output.freeze(); @@ -246,10 +237,10 @@ public: return {DocumentSource::GetModPathsReturn::Type::kAllPaths, {}, {}}; } - OrderedPathSet preservedPaths; + std::set<std::string> preservedPaths; _root->reportProjectedPaths(&preservedPaths); - OrderedPathSet computedPaths; + std::set<std::string> computedPaths; StringMap<std::string> renamedPaths; _root->reportComputedPaths(&computedPaths, &renamedPaths); diff --git a/src/mongo/db/exec/inclusion_projection_executor_test.cpp b/src/mongo/db/exec/inclusion_projection_executor_test.cpp index b31899043ca..84ed31a9bb4 100644 --- a/src/mongo/db/exec/inclusion_projection_executor_test.cpp +++ b/src/mongo/db/exec/inclusion_projection_executor_test.cpp @@ -814,20 +814,18 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, "i: {$meta: 'recordId'}, " "j: {$meta: 'indexKey'}, " "k: {$meta: 'sortKey'}, " - "l: {$meta: 'searchScoreDetails'}}, " - "m: {$meta: 'vectorSearchScore'}")); + "l: {$meta: 'searchScoreDetails'}}")); DepsTracker deps; inclusion->addDependencies(&deps); ASSERT_EQ(deps.fields.size(), 2UL); - // We do not add the dependencies for searchScore, searchHighlights, searchScoreDetails, or - // distance because those values are not stored in the collection (or in mongod at all). + // We do not add the dependencies for searchScore, searchHighlights, or searchScoreDetails + // because those values are not stored in the collection (or in mongod at all). ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchScore]); ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchHighlights]); ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kSearchScoreDetails]); - ASSERT_FALSE(deps.metadataDeps()[DocumentMetadataFields::kVectorSearchScore]); ASSERT_TRUE(deps.metadataDeps()[DocumentMetadataFields::kTextScore]); ASSERT_TRUE(deps.metadataDeps()[DocumentMetadataFields::kRandVal]); @@ -849,8 +847,7 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, ShouldEvaluateMeta "i: {$meta: 'recordId'}, " "j: {$meta: 'indexKey'}, " "k: {$meta: 'sortKey'}, " - "l: {$meta: 'searchScoreDetails'}, " - "m: {$meta: 'vectorSearchScore'}}")); + "l: {$meta: 'searchScoreDetails'}}")); MutableDocument inputDocBuilder(Document{{"a", 1}}); inputDocBuilder.metadata().setTextScore(0.0); @@ -864,7 +861,6 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, ShouldEvaluateMeta inputDocBuilder.metadata().setSortKey(Value{Document{{"bar", 8}}}, true); inputDocBuilder.metadata().setSearchScoreDetails(BSON("scoreDetails" << "foo")); - inputDocBuilder.metadata().setVectorSearchScore(9.0); Document inputDoc = inputDocBuilder.freeze(); auto result = inclusion->applyTransformation(inputDoc); @@ -872,7 +868,7 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, ShouldEvaluateMeta ASSERT_DOCUMENT_EQ(result, Document{fromjson("{a: 1, c: 0.0, d: 1.0, e: 2.0, f: 'foo', g: 3.0, " "h: [4, 5], i: 6, j: {foo: 7}, k: [{bar: 8}], " - "l: {scoreDetails: 'foo'}, m: 9.0}")}); + "l: {scoreDetails: 'foo'}}")}); } // @@ -1094,62 +1090,6 @@ TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, ASSERT_DOCUMENT_EQ(expectedProjection, inclusion->serializeTransformation(boost::none)); } -TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, - ExtractComputedProjectionInProjectShouldNotIncludeId) { - auto inclusion = makeInclusionProjectionWithDefaultPolicies( - BSON("a" << BSON("$sum" << BSON_ARRAY("$myMeta" - << "$_id")))); - - auto r = static_cast<InclusionProjectionExecutor*>(inclusion.get())->getRoot(); - const std::set<StringData> reservedNames{}; - auto [addFields, deleteFlag] = - r->extractComputedProjectionsInProject("myMeta", "meta", reservedNames); - - ASSERT_EQ(addFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = Document(fromjson("{_id: true, a: {$sum: ['$myMeta', '$_id']}}")); - ASSERT_DOCUMENT_EQ(expectedProjection, inclusion->serializeTransformation(boost::none)); -} - -TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, - ExtractComputedProjectionInProjectShouldNotHideDependentSubFields) { - auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a" - << "$myMeta" - << "b" - << "$a.x")); - - auto r = static_cast<InclusionProjectionExecutor*>(inclusion.get())->getRoot(); - const std::set<StringData> reservedNames{}; - auto [addFields, deleteFlag] = - r->extractComputedProjectionsInProject("myMeta", "meta", reservedNames); - - ASSERT_EQ(addFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = Document(fromjson("{_id: true, a: '$myMeta', b: '$a.x'}")); - ASSERT_DOCUMENT_EQ(expectedProjection, inclusion->serializeTransformation(boost::none)); -} - -TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, - ExtractComputedProjectionInProjectShouldNotHideDependentSubFieldsWithDottedSibling) { - auto inclusion = makeInclusionProjectionWithDefaultPolicies(BSON("a" - << "$myMeta" - << "c.b" - << "$a.x")); - - auto r = static_cast<InclusionProjectionExecutor*>(inclusion.get())->getRoot(); - const std::set<StringData> reservedNames{}; - auto [addFields, deleteFlag] = - r->extractComputedProjectionsInProject("myMeta", "meta", reservedNames); - - ASSERT_EQ(addFields.nFields(), 0); - ASSERT_EQ(deleteFlag, false); - - auto expectedProjection = Document(fromjson("{_id: true, a: '$myMeta', c: {b: '$a.x'}}")); - ASSERT_DOCUMENT_EQ(expectedProjection, inclusion->serializeTransformation(boost::none)); -} - TEST_F(InclusionProjectionExecutionTestWithFallBackToDefault, ApplyProjectionAfterSplit) { auto inclusion = makeInclusionProjectionWithDefaultPolicies( BSON("a" << true << "computedMeta1" diff --git a/src/mongo/db/exec/index_scan.cpp b/src/mongo/db/exec/index_scan.cpp index c61fc452ec7..06399c4e33b 100644 --- a/src/mongo/db/exec/index_scan.cpp +++ b/src/mongo/db/exec/index_scan.cpp @@ -280,7 +280,9 @@ std::unique_ptr<PlanStageStats> IndexScan::getStats() { // Add a BSON representation of the filter to the stats tree, if there is one. if (nullptr != _filter) { - _commonStats.filter = _filter->serialize(); + BSONObjBuilder bob; + _filter->serialize(&bob); + _commonStats.filter = bob.obj(); } // These specific stats fields never change. diff --git a/src/mongo/db/exec/multi_plan.cpp b/src/mongo/db/exec/multi_plan.cpp index 00254cef133..def29719b63 100644 --- a/src/mongo/db/exec/multi_plan.cpp +++ b/src/mongo/db/exec/multi_plan.cpp @@ -190,13 +190,14 @@ PlanStage::StageState MultiPlanStage::doWork(WorkingSetID* out) { .getPlanCache() ->remove(plan_cache_key_factory::make<PlanCacheKey>(*_query, collection())); - switchToBackupPlan(); + _bestPlanIdx = _backupPlanIdx; + _backupPlanIdx = kNoSuchPlan; return _candidates[_bestPlanIdx].root->work(out); } if (hasBackupPlan() && PlanStage::ADVANCED == state) { LOGV2_DEBUG(20589, 5, "Best plan had a blocking stage, became unblocked"); - removeBackupPlan(); + _backupPlanIdx = kNoSuchPlan; } return state; @@ -293,7 +294,6 @@ Status MultiPlanStage::pickBestPlan(PlanYieldPolicy* yieldPolicy) { plan_cache_util::updatePlanCache( expCtx()->opCtx, collection(), _cachingMode, *_query, std::move(ranking), _candidates); - removeRejectedPlans(); return Status::OK(); } @@ -364,54 +364,6 @@ bool MultiPlanStage::workAllPlans(size_t numResults, PlanYieldPolicy* yieldPolic return !doneWorking; } -void MultiPlanStage::removeRejectedPlans() { - // Move the best plan and the backup plan to the front of 'children'. - if (_bestPlanIdx != 0) { - std::swap(_children[_bestPlanIdx], _children[0]); - std::swap(_candidates[_bestPlanIdx], _candidates[0]); - if (_backupPlanIdx == 0) { - _backupPlanIdx = _bestPlanIdx; - } - _bestPlanIdx = 0; - } - size_t startIndex = 1; - if (_backupPlanIdx != kNoSuchPlan) { - if (_backupPlanIdx != 1) { - std::swap(_children[_backupPlanIdx], _children[1]); - std::swap(_candidates[_backupPlanIdx], _candidates[1]); - _backupPlanIdx = 1; - } - startIndex = 2; - } - - _rejected.reserve(_children.size() - startIndex); - for (size_t i = startIndex; i < _children.size(); ++i) { - rejectPlan(i); - } - _children.resize(startIndex); -} - -void MultiPlanStage::switchToBackupPlan() { - std::swap(_children[_backupPlanIdx], _children[_bestPlanIdx]); - std::swap(_candidates[_backupPlanIdx], _candidates[_bestPlanIdx]); - removeBackupPlan(); -} - -void MultiPlanStage::rejectPlan(size_t planIdx) { - auto rejectedPlan = std::move(_children[planIdx]); - if (opCtx() != nullptr) { - rejectedPlan->saveState(); - rejectedPlan->detachFromOperationContext(); - } - _rejected.emplace_back(std::move(rejectedPlan)); -} - -void MultiPlanStage::removeBackupPlan() { - rejectPlan(_backupPlanIdx); - _children.resize(1); - _backupPlanIdx = kNoSuchPlan; -} - bool MultiPlanStage::hasBackupPlan() const { return kNoSuchPlan != _backupPlanIdx; } @@ -446,9 +398,6 @@ unique_ptr<PlanStageStats> MultiPlanStage::getStats() { for (auto&& child : _children) { ret->children.emplace_back(child->getStats()); } - for (auto&& child : _rejected) { - ret->children.emplace_back(child->getStats()); - } return ret; } diff --git a/src/mongo/db/exec/multi_plan.h b/src/mongo/db/exec/multi_plan.h index 12ab61659db..14d8ea413af 100644 --- a/src/mongo/db/exec/multi_plan.h +++ b/src/mongo/db/exec/multi_plan.h @@ -75,6 +75,7 @@ public: std::unique_ptr<PlanStageStats> getStats() final; + const SpecificStats* getSpecificStats() const final; boost::optional<double> getCandidateScore(size_t candidateIdx) const; @@ -162,19 +163,6 @@ private: */ void tryYield(PlanYieldPolicy* yieldPolicy); - /** - * Deletes all children, except for best and backup plans. - * - * This is necessary to release any resources that rejected plans might have. - * For example, if multi-update can be done by scanning several indexes, - * it will be slowed down by rejected index scans because of index cursors - * that need to be reopeneed after every update. - */ - void removeRejectedPlans(); - void rejectPlan(size_t planIdx); - void switchToBackupPlan(); - void removeBackupPlan(); - static const int kNoSuchPlan = -1; // Describes the cases in which we should write an entry for the winning plan to the plan cache. @@ -190,9 +178,6 @@ private: // one-to-one with _candidates. std::vector<plan_ranker::CandidatePlan> _candidates; - // Rejected plans in saved and detached state. - std::vector<std::unique_ptr<PlanStage>> _rejected; - // index into _candidates, of the winner of the plan competition // uses -1 / kNoSuchPlan when best plan is not (yet) known int _bestPlanIdx; diff --git a/src/mongo/db/exec/or.cpp b/src/mongo/db/exec/or.cpp index 078765ffc84..ec0d680ac37 100644 --- a/src/mongo/db/exec/or.cpp +++ b/src/mongo/db/exec/or.cpp @@ -122,8 +122,10 @@ unique_ptr<PlanStageStats> OrStage::getStats() { _commonStats.isEOF = isEOF(); // Add a BSON representation of the filter to the stats tree, if there is one. - if (_filter) { - _commonStats.filter = _filter->serialize(); + if (nullptr != _filter) { + BSONObjBuilder bob; + _filter->serialize(&bob); + _commonStats.filter = bob.obj(); } unique_ptr<PlanStageStats> ret = std::make_unique<PlanStageStats>(_commonStats, STAGE_OR); diff --git a/src/mongo/db/exec/projection.h b/src/mongo/db/exec/projection.h index 236792ce64a..00e7fb33dbc 100644 --- a/src/mongo/db/exec/projection.h +++ b/src/mongo/db/exec/projection.h @@ -33,7 +33,6 @@ #include "mongo/db/exec/projection_executor.h" #include "mongo/db/jsobj.h" #include "mongo/db/matcher/expression.h" -#include "mongo/db/query/projection.h" #include "mongo/db/query/projection_ast.h" #include "mongo/db/record_id.h" diff --git a/src/mongo/db/exec/projection_executor.h b/src/mongo/db/exec/projection_executor.h index 449ef8c3a7b..ca8e0d3990c 100644 --- a/src/mongo/db/exec/projection_executor.h +++ b/src/mongo/db/exec/projection_executor.h @@ -38,7 +38,6 @@ #include "mongo/db/pipeline/expression_context.h" #include "mongo/db/pipeline/field_path.h" #include "mongo/db/pipeline/transformer_interface.h" -#include "mongo/db/query/projection_ast.h" #include "mongo/db/query/projection_policies.h" namespace mongo::projection_executor { @@ -98,20 +97,10 @@ public: */ virtual boost::optional<std::set<FieldRef>> extractExhaustivePaths() const = 0; - /** - * The query shape is made by serializing the first parsed representation of the query, which in - * the case of $project queries is a projection_ast::Projection. The ProjectionExecutor, holds - * onto the root node of the AST for only $project queries, so that the first parsed - * representation is accessible at serialization. - */ - boost::optional<projection_ast::ProjectionPathASTNode> projection = boost::none; - protected: ProjectionExecutor(const boost::intrusive_ptr<ExpressionContext>& expCtx, - ProjectionPolicies policies, - boost::optional<projection_ast::ProjectionPathASTNode> proj = boost::none) - : projection(proj), - _expCtx(expCtx), + ProjectionPolicies policies) + : _expCtx(expCtx), _policies(policies), _projectionPostImageVarId{ _expCtx->variablesParseState.defineVariable(kProjectionPostImageVarName)} {} diff --git a/src/mongo/db/exec/projection_executor_builder.cpp b/src/mongo/db/exec/projection_executor_builder.cpp index f5e94be3f78..1b712685ea9 100644 --- a/src/mongo/db/exec/projection_executor_builder.cpp +++ b/src/mongo/db/exec/projection_executor_builder.cpp @@ -251,7 +251,7 @@ auto buildProjectionExecutor(boost::intrusive_ptr<ExpressionContext> expCtx, const ProjectionPolicies policies, const BuilderParamsBitSet params) { ProjectionExecutorVisitorContext<Executor> context{ - {std::make_unique<Executor>(expCtx, policies, params[kAllowFastPath], *root), expCtx}}; + {std::make_unique<Executor>(expCtx, policies, params[kAllowFastPath]), expCtx}}; ProjectionExecutorVisitor<Executor> executorVisitor{&context}; projection_ast::PathTrackingWalker walker{&context, {&executorVisitor}, {}}; tree_walker::walk<true, projection_ast::ASTNode>(root, &walker); diff --git a/src/mongo/db/exec/projection_executor_builder.h b/src/mongo/db/exec/projection_executor_builder.h index 12f683a1cba..476f2b63a25 100644 --- a/src/mongo/db/exec/projection_executor_builder.h +++ b/src/mongo/db/exec/projection_executor_builder.h @@ -32,7 +32,6 @@ #include <bitset> #include "mongo/db/exec/projection_executor.h" -#include "mongo/db/query/projection.h" #include "mongo/db/query/projection_ast.h" namespace mongo::projection_executor { diff --git a/src/mongo/db/exec/projection_executor_redaction_test.cpp b/src/mongo/db/exec/projection_executor_redaction_test.cpp deleted file mode 100644 index 70eb59855bb..00000000000 --- a/src/mongo/db/exec/projection_executor_redaction_test.cpp +++ /dev/null @@ -1,208 +0,0 @@ -/** - * Copyright (C) 2023-present MongoDB, Inc. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the Server Side Public License, version 1, - * as published by MongoDB, Inc. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * Server Side Public License for more details. - * - * You should have received a copy of the Server Side Public License - * along with this program. If not, see - * <http://www.mongodb.com/licensing/server-side-public-license>. - * - * As a special exception, the copyright holders give permission to link the - * code of portions of this program with the OpenSSL library under certain - * conditions as described in each individual source file and distribute - * linked combinations including the program with the OpenSSL library. You - * must comply with the Server Side Public License in all respects for - * all of the code used other than as permitted herein. If you modify file(s) - * with this exception, you may extend this exception to your version of the - * file(s), but you are not obligated to do so. If you do not wish to do so, - * delete this exception statement from your version. If you delete this - * exception statement from all source files in the program, then also delete - * it in the license file. - */ - -#include "document_value/document_value_test_util.h" -#include "mongo/db/exec/projection_executor.h" -#include "mongo/db/exec/projection_executor_builder.h" -#include "mongo/db/matcher/expression_parser.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/projection_parser.h" -#include "mongo/db/query/projection_policies.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/unittest/unittest.h" - -namespace mongo { -namespace { -std::unique_ptr<projection_executor::ProjectionExecutor> compileProjection(BSONObj proj) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto policies = ProjectionPolicies::findProjectionPolicies(); - auto ast = projection_ast::parseAndAnalyze(expCtx, proj, policies); - return projection_executor::buildProjectionExecutor( - expCtx, &ast, policies, projection_executor::kDefaultBuilderParams); -} -std::unique_ptr<projection_executor::ProjectionExecutor> compileProjection(BSONObj proj, - BSONObj query) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto match = uassertStatusOK(MatchExpressionParser::parse(query, expCtx)); - auto policies = ProjectionPolicies::findProjectionPolicies(); - auto ast = projection_ast::parseAndAnalyze(expCtx, proj, match.get(), query, policies); - auto exec = projection_executor::buildProjectionExecutor( - expCtx, &ast, policies, projection_executor::kDefaultBuilderParams); - return exec; -} - -TEST(Redaction, ProjectionTest) { - SerializationOptions options = SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST; - auto redactProj = [&](std::string obj) { - return compileProjection(fromjson(obj))->serializeTransformation(boost::none, options); - }; - - /// Inclusion projections - - // Simple single inclusion - auto actual = redactProj("{a: 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":true})", - actual); - - actual = redactProj("{a: true}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":true})", - actual); - - // Dotted path - actual = redactProj("{\"a.b\": 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":{"HASH<b>":true}})", - actual); - - // Two fields - actual = redactProj("{a: 1, b: 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":true,"HASH<b>":true})", - actual); - - // Explicit _id: 1 - actual = redactProj("{b: 1, _id: 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<b>":true})", - actual); - - // Two nested fields - actual = redactProj("{\"b.d\": 1, \"b.c\": 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<b>":{"HASH<d>":true,"HASH<c>":true}})", - actual); - - actual = redactProj("{\"b.d\": 1, a: 1, \"b.c\": 1}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({ - "HASH<_id>": true, - "HASH<a>": true, - "HASH<b>": { - "HASH<d>": true, - "HASH<c>": true - } - })", - actual); - - /// Exclusion projections - - // Simple single exclusion - actual = redactProj("{a: 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<a>":false,"HASH<_id>":true})", - actual); - - // Dotted path - actual = redactProj("{\"a.b\": 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<a>":{"HASH<b>":false},"HASH<_id>":true})", - actual); - - // Two fields - actual = redactProj("{a: 0, b: 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<a>":false,"HASH<b>":false,"HASH<_id>":true})", - actual); - - // Explicit _id: 0 - actual = redactProj("{b: 0, _id: 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":false,"HASH<b>":false})", - actual); - - // Two nested fields - actual = redactProj("{\"b.d\": 0, \"b.c\": 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<b>":{"HASH<d>":false,"HASH<c>":false},"HASH<_id>":true})", - actual); - - actual = redactProj("{\"b.d\": 0, a: 0, \"b.c\": 0}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({ - "HASH<a>": false, - "HASH<b>": { - "HASH<d>": false, - "HASH<c>": false - }, - "HASH<_id>": true - })", - actual); - - /// Add fields projection - actual = redactProj("{a: \"hi\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":"?string"})", - actual); - - actual = redactProj("{a: '$field'}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":"$HASH<field>"})", - actual); - - // Dotted path - actual = redactProj("{\"a.b\": \"hi\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":{"HASH<b>":"?string"}})", - actual); - - // Two fields - actual = redactProj("{a: \"hi\", b: \"hello\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<a>":"?string","HASH<b>":"?string"})", - actual); - - // Explicit _id: 0 - actual = redactProj("{b: \"hi\", _id: \"hey\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<b>":"?string","HASH<_id>":"?string"})", - actual); - - // Two nested fields - actual = redactProj("{\"b.d\": \"hello\", \"b.c\": \"world\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<_id>":true,"HASH<b>":{"HASH<d>":"?string","HASH<c>":"?string"}})", - actual); - - actual = redactProj("{\"b.d\": \"hello\", a: \"world\", \"b.c\": \"mongodb\"}"); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({ - "HASH<_id>": true, - "HASH<b>": { - "HASH<d>": "?string", - "HASH<c>": "?string" - }, - "HASH<a>": "?string" - })", - actual); -} -} // namespace -} // namespace mongo diff --git a/src/mongo/db/exec/projection_executor_wildcard_access_test.cpp b/src/mongo/db/exec/projection_executor_wildcard_access_test.cpp index fc1e74a0c2e..bdf5dea8241 100644 --- a/src/mongo/db/exec/projection_executor_wildcard_access_test.cpp +++ b/src/mongo/db/exec/projection_executor_wildcard_access_test.cpp @@ -74,7 +74,7 @@ std::unique_ptr<ProjectionExecutor> makeProjectionWithDefaultIdExclusionAndNeste return createProjectionExecutor(projSpec, policies); } -std::set<FieldRef> toFieldRefs(const OrderedPathSet& stringPaths) { +std::set<FieldRef> toFieldRefs(const std::set<std::string>& stringPaths) { std::set<FieldRef> fieldRefs; std::transform(stringPaths.begin(), stringPaths.end(), diff --git a/src/mongo/db/exec/projection_node.cpp b/src/mongo/db/exec/projection_node.cpp index 6b053c4593f..1ef569ecd75 100644 --- a/src/mongo/db/exec/projection_node.cpp +++ b/src/mongo/db/exec/projection_node.cpp @@ -48,8 +48,7 @@ void ProjectionNode::addProjectionForPath(const FieldPath& path) { void ProjectionNode::_addProjectionForPath(const FieldPath& path) { makeOptimizationsStale(); if (path.getPathLength() == 1) { - auto it = _projectedFields.insert(_projectedFields.end(), path.fullPath()); - _projectedFieldsSet.insert(StringData(*it)); + _projectedFields.insert(path.fullPath()); return; } // FieldPath can't be empty, so it is safe to obtain the first path component here. @@ -139,18 +138,12 @@ void ProjectionNode::applyProjections(const Document& inputDoc, MutableDocument* auto it = inputDoc.fieldIterator(); size_t projectedFields = 0; - bool isIncl = isIncluded(); - while (it.more()) { auto fieldName = it.fieldName(); - if (_projectedFieldsSet.find(fieldName) != _projectedFieldsSet.end()) { - if (isIncl) { - outputProjectedField(fieldName, it.next().second, outputDoc); - } else { - outputProjectedField(fieldName, Value(), outputDoc); - it.advance(); - } + if (_projectedFields.find(fieldName) != _projectedFields.end()) { + outputProjectedField( + fieldName, applyLeafProjectionToValue(it.next().second), outputDoc); ++projectedFields; } else if (auto childIt = _children.find(fieldName); childIt != _children.end()) { outputProjectedField( @@ -236,7 +229,7 @@ Value ProjectionNode::applyExpressionsToValue(const Document& root, Value inputV } } -void ProjectionNode::reportProjectedPaths(OrderedPathSet* projectedPaths) const { +void ProjectionNode::reportProjectedPaths(std::set<std::string>* projectedPaths) const { for (auto&& projectedField : _projectedFields) { projectedPaths->insert(FieldPath::getFullyQualifiedPath(_pathToNode, projectedField)); } @@ -246,7 +239,7 @@ void ProjectionNode::reportProjectedPaths(OrderedPathSet* projectedPaths) const } } -void ProjectionNode::reportComputedPaths(OrderedPathSet* computedPaths, +void ProjectionNode::reportComputedPaths(std::set<std::string>* computedPaths, StringMap<std::string>* renamedPaths) const { for (auto&& computedPair : _expressions) { // The expression's path is the concatenation of the path to this node, plus the field name @@ -275,27 +268,25 @@ void ProjectionNode::optimize() { _maxFieldsToProject = maxFieldsToProject(); } -Document ProjectionNode::serialize(boost::optional<ExplainOptions::Verbosity> explain, - const SerializationOptions& options) const { +Document ProjectionNode::serialize(boost::optional<ExplainOptions::Verbosity> explain) const { MutableDocument outputDoc; - serialize(explain, &outputDoc, options); + serialize(explain, &outputDoc); return outputDoc.freeze(); } void ProjectionNode::serialize(boost::optional<ExplainOptions::Verbosity> explain, - MutableDocument* output, - const SerializationOptions& options) const { + MutableDocument* output) const { // Determine the boolean value for projected fields in the explain output. - const bool projVal = isIncluded(); + const bool projVal = !applyLeafProjectionToValue(Value(true)).missing(); // Always put "_id" first if it was projected (implicitly or explicitly). - if (_projectedFieldsSet.find("_id") != _projectedFieldsSet.end()) { - output->addField(options.serializeFieldPath("_id"), Value(projVal)); + if (_projectedFields.find("_id") != _projectedFields.end()) { + output->addField("_id", Value(projVal)); } for (auto&& projectedField : _projectedFields) { if (projectedField != "_id") { - output->addField(options.serializeFieldPathFromString(projectedField), Value(projVal)); + output->addField(projectedField, Value(projVal)); } } @@ -303,14 +294,13 @@ void ProjectionNode::serialize(boost::optional<ExplainOptions::Verbosity> explai auto childIt = _children.find(field); if (childIt != _children.end()) { MutableDocument subDoc; - childIt->second->serialize(explain, &subDoc, options); - output->addField(options.serializeFieldPathFromString(field), subDoc.freezeToValue()); + childIt->second->serialize(explain, &subDoc); + output->addField(field, subDoc.freezeToValue()); } else { invariant(_policies.computedFieldsPolicy == ComputedFieldsPolicy::kAllowComputedFields); auto expressionIt = _expressions.find(field); invariant(expressionIt != _expressions.end()); - output->addField(options.serializeFieldPathFromString(field), - expressionIt->second->serialize(options)); + output->addField(field, expressionIt->second->serialize(static_cast<bool>(explain))); } } } diff --git a/src/mongo/db/exec/projection_node.h b/src/mongo/db/exec/projection_node.h index cd744ef4cac..2a587580330 100644 --- a/src/mongo/db/exec/projection_node.h +++ b/src/mongo/db/exec/projection_node.h @@ -29,9 +29,8 @@ #pragma once -#include <list> - #include "mongo/db/exec/projection_executor.h" + #include "mongo/db/query/projection_policies.h" namespace mongo::projection_executor { @@ -103,7 +102,7 @@ public: /** * Recursively report all paths that are referenced by this projection. */ - void reportProjectedPaths(OrderedPathSet* preservedPaths) const; + void reportProjectedPaths(std::set<std::string>* preservedPaths) const; /** * Return an optional number, x, which indicates that it is safe to stop reading the document @@ -120,7 +119,7 @@ public: * 'renamedPaths'. Each entry in 'renamedPaths' maps from the path's new name to its old name * prior to application of this projection. */ - void reportComputedPaths(OrderedPathSet* computedPaths, + void reportComputedPaths(std::set<std::string>* computedPaths, StringMap<std::string>* renamedPaths) const; const std::string& getPath() const { @@ -129,12 +128,10 @@ public: void optimize(); - Document serialize(boost::optional<ExplainOptions::Verbosity> explain, - const SerializationOptions& options) const; + Document serialize(boost::optional<ExplainOptions::Verbosity> explain) const; void serialize(boost::optional<ExplainOptions::Verbosity> explain, - MutableDocument* output, - const SerializationOptions& options) const; + MutableDocument* output) const; protected: /** @@ -163,19 +160,9 @@ protected: // Writes the given value to the output doc, replacing the existing value of 'field' if present. virtual void outputProjectedField(StringData field, Value val, MutableDocument* outDoc) const; - // Used to determine if the node is an inclusion or exclusion node. - virtual bool isIncluded() const = 0; - StringMap<std::unique_ptr<ProjectionNode>> _children; StringMap<boost::intrusive_ptr<Expression>> _expressions; - - // List of the projected fields in the order in which they were specified. - std::list<std::string> _projectedFields; - - // Set of projected fields. Note that the _projectedFields list actually owns the strings, and - // this StringDataSet simply holds views of those strings. - StringDataSet _projectedFieldsSet; - + StringSet _projectedFields; ProjectionPolicies _policies; std::string _pathToNode; diff --git a/src/mongo/db/exec/sbe/SConscript b/src/mongo/db/exec/sbe/SConscript index f8246baf556..b99625b0833 100644 --- a/src/mongo/db/exec/sbe/SConscript +++ b/src/mongo/db/exec/sbe/SConscript @@ -23,7 +23,7 @@ env.Library( '$BUILD_DIR/mongo/base', '$BUILD_DIR/mongo/db/exec/js_function', '$BUILD_DIR/mongo/db/fts/base_fts', - '$BUILD_DIR/mongo/db/index/index_access_method', + '$BUILD_DIR/mongo/db/index/key_generator', '$BUILD_DIR/mongo/db/query/collation/collator_interface', '$BUILD_DIR/mongo/db/query/datetime/date_time_support', '$BUILD_DIR/mongo/db/query/query_index_bounds', @@ -59,9 +59,8 @@ sbeEnv.Library( LIBDEPS_PRIVATE=[ '$BUILD_DIR/mongo/db/bson/dotted_path_support', '$BUILD_DIR/mongo/db/sorter/sorter_idl', - '$BUILD_DIR/mongo/db/sorter/sorter_stats', - ], -) + ] + ) sbeEnv.Library( target='query_sbe_stages', @@ -90,6 +89,7 @@ sbeEnv.Library( LIBDEPS=[ '$BUILD_DIR/mongo/base', '$BUILD_DIR/mongo/db/concurrency/lock_manager', + '$BUILD_DIR/mongo/db/concurrency/write_conflict_exception', '$BUILD_DIR/mongo/db/exec/js_function', '$BUILD_DIR/mongo/db/exec/scoped_timer', '$BUILD_DIR/mongo/db/query/plan_yield_policy', @@ -106,7 +106,6 @@ sbeEnv.Library( LIBDEPS_PRIVATE=[ '$BUILD_DIR/mongo/db/bson/dotted_path_support', '$BUILD_DIR/mongo/db/sorter/sorter_idl', - '$BUILD_DIR/mongo/db/sorter/sorter_stats', 'query_sbe', 'query_sbe_storage', ] diff --git a/src/mongo/db/exec/sbe/abt/abt_lower.cpp b/src/mongo/db/exec/sbe/abt/abt_lower.cpp index 7939d166a78..7da6a8e2cef 100644 --- a/src/mongo/db/exec/sbe/abt/abt_lower.cpp +++ b/src/mongo/db/exec/sbe/abt/abt_lower.cpp @@ -586,15 +586,14 @@ std::unique_ptr<sbe::PlanStage> SBENodeLowering::walk(const GroupByNode& n, auto& names = binderAgg->names(); auto& exprs = refsAgg->nodes(); - sbe::SlotExprPairVector aggs; - aggs.reserve(exprs.size()); + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> aggs; for (size_t idx = 0; idx < exprs.size(); ++idx) { auto expr = SBEExpressionLowering{_env, _slotMap}.optimize(exprs[idx]); auto slot = _slotIdGenerator.generate(); _slotMap.emplace(names[idx], slot); - aggs.push_back({slot, std::move(expr)}); + aggs.emplace(slot, std::move(expr)); } // TODO: use collator slot. @@ -610,11 +609,6 @@ std::unique_ptr<sbe::PlanStage> SBENodeLowering::walk(const GroupByNode& n, true /*optimizedClose*/, collatorSlot, false /*allowDiskUse*/, - // Since we are always disallowing disk use for this stage, - // we need not provide merging expressions. Once spilling - // is permitted here, we will need to generate merging - // expressions during lowering. - sbe::makeSlotExprPairVec() /*mergingExprs*/, planNodeId); } @@ -1011,7 +1005,6 @@ std::unique_ptr<sbe::PlanStage> SBENodeLowering::walk(const IndexScanNode& n, co resultSlot, ridSlot, boost::none, - boost::none, indexKeysToInclude, vars, seekKeySlotLower, diff --git a/src/mongo/db/exec/sbe/expression_test_base.h b/src/mongo/db/exec/sbe/expression_test_base.h index bc5121407f9..72d9820d760 100644 --- a/src/mongo/db/exec/sbe/expression_test_base.h +++ b/src/mongo/db/exec/sbe/expression_test_base.h @@ -69,24 +69,6 @@ protected: } /** - * Compiles 'expr' to bytecode when 'expr' is computing an aggregate. The current aggregate - * value can be read out of the provided 'aggAccessor'. - * - * Note that when actually executing the resulting bytecode, the caller is responsible for - * setting the value of 'aggAccessor' to the new resulting aggregate value. - */ - std::unique_ptr<vm::CodeFragment> compileAggExpression(const EExpression& expr, - value::SlotAccessor* aggAccessor) { - ON_BLOCK_EXIT([this] { - _ctx.aggExpression = false; - _ctx.accumulator = nullptr; - }); - _ctx.aggExpression = true; - _ctx.accumulator = aggAccessor; - return expr.compile(_ctx); - } - - /** * The caller takes ownership of the Value returned by this function and must call * 'releaseValue()' on it. The preferred way to ensure the Value is properly released is to * immediately store it in a ValueGuard. diff --git a/src/mongo/db/exec/sbe/expressions/expression.cpp b/src/mongo/db/exec/sbe/expressions/expression.cpp index 65421e8b373..3a2b20a4657 100644 --- a/src/mongo/db/exec/sbe/expressions/expression.cpp +++ b/src/mongo/db/exec/sbe/expressions/expression.cpp @@ -429,8 +429,6 @@ static stdx::unordered_map<std::string, BuiltinFn> kBuiltinFunctions = { BuiltinFn{[](size_t n) { return n > 0; }, vm::Builtin::doubleDoubleSum, false}}, {"aggDoubleDoubleSum", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::aggDoubleDoubleSum, true}}, - {"aggMergeDoubleDoubleSums", - BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::aggMergeDoubleDoubleSums, true}}, {"doubleDoubleSumFinalize", BuiltinFn{[](size_t n) { return n > 0; }, vm::Builtin::doubleDoubleSumFinalize, false}}, {"doubleDoubleMergeSumFinalize", @@ -438,8 +436,6 @@ static stdx::unordered_map<std::string, BuiltinFn> kBuiltinFunctions = { {"doubleDoublePartialSumFinalize", BuiltinFn{[](size_t n) { return n > 0; }, vm::Builtin::doubleDoublePartialSumFinalize, false}}, {"aggStdDev", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::aggStdDev, true}}, - {"aggMergeStdDevs", - BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::aggMergeStdDevs, true}}, {"stdDevPopFinalize", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::stdDevPopFinalize, false}}, {"stdDevSampFinalize", @@ -471,10 +467,7 @@ static stdx::unordered_map<std::string, BuiltinFn> kBuiltinFunctions = { {"tan", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::tan, false}}, {"tanh", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::tanh, false}}, {"round", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::round, false}}, - {"concat", BuiltinFn{kAnyNumberOfArgs, vm::Builtin::concat, false}}, - {"concatArrays", BuiltinFn{kAnyNumberOfArgs, vm::Builtin::concatArrays, false}}, - {"aggConcatArraysCapped", - BuiltinFn{[](size_t n) { return n == 2; }, vm::Builtin::aggConcatArraysCapped, true}}, + {"concat", BuiltinFn{[](size_t n) { return n > 0; }, vm::Builtin::concat, false}}, {"isMember", BuiltinFn{[](size_t n) { return n == 2; }, vm::Builtin::isMember, false}}, {"collIsMember", BuiltinFn{[](size_t n) { return n == 3; }, vm::Builtin::collIsMember, false}}, {"indexOfBytes", @@ -493,11 +486,6 @@ static stdx::unordered_map<std::string, BuiltinFn> kBuiltinFunctions = { BuiltinFn{[](size_t n) { return n >= 1; }, vm::Builtin::collSetIntersection, false}}, {"collSetDifference", BuiltinFn{[](size_t n) { return n == 3; }, vm::Builtin::collSetDifference, false}}, - {"aggSetUnion", BuiltinFn{[](size_t n) { return n == 1; }, vm::Builtin::aggSetUnion, true}}, - {"aggSetUnionCapped", - BuiltinFn{[](size_t n) { return n == 2; }, vm::Builtin::aggSetUnionCapped, true}}, - {"aggCollSetUnionCapped", - BuiltinFn{[](size_t n) { return n == 3; }, vm::Builtin::aggCollSetUnionCapped, true}}, {"runJsPredicate", BuiltinFn{[](size_t n) { return n == 2; }, vm::Builtin::runJsPredicate, false}}, {"regexCompile", BuiltinFn{[](size_t n) { return n == 2; }, vm::Builtin::regexCompile, false}}, diff --git a/src/mongo/db/exec/sbe/expressions/expression.h b/src/mongo/db/exec/sbe/expressions/expression.h index d5a2c0fdf0e..2b9032f257b 100644 --- a/src/mongo/db/exec/sbe/expressions/expression.h +++ b/src/mongo/db/exec/sbe/expressions/expression.h @@ -348,8 +348,6 @@ private: std::string toString() const; }; -using SlotExprPairVector = std::vector<std::pair<value::SlotId, std::unique_ptr<EExpression>>>; - template <typename T, typename... Args> inline std::unique_ptr<EExpression> makeE(Args&&... args) { return std::make_unique<T>(std::forward<Args>(args)...); @@ -366,30 +364,20 @@ inline auto makeEs(Ts&&... pack) { namespace detail { // base case -template <typename R> -inline void makeSlotExprPairHelper(R& result, - value::SlotId slot, - std::unique_ptr<EExpression> expr) { - if constexpr (std::is_same_v<R, value::SlotMap<std::unique_ptr<EExpression>>>) { - result.emplace(slot, std::move(expr)); - } else { - result.push_back({slot, std::move(expr)}); - } +inline void makeEM_unwind(value::SlotMap<std::unique_ptr<EExpression>>& result, + value::SlotId slot, + std::unique_ptr<EExpression> expr) { + result.emplace(slot, std::move(expr)); } // recursive case -template <typename R, typename... Ts> -inline void makeSlotExprPairHelper(R& result, - value::SlotId slot, - std::unique_ptr<EExpression> expr, - Ts&&... rest) { - if constexpr (std::is_same_v<R, value::SlotMap<std::unique_ptr<EExpression>>>) { - result.emplace(slot, std::move(expr)); - } else { - static_assert(std::is_same_v<R, SlotExprPairVector>); - result.push_back({slot, std::move(expr)}); - } - makeSlotExprPairHelper(result, std::forward<Ts>(rest)...); +template <typename... Ts> +inline void makeEM_unwind(value::SlotMap<std::unique_ptr<EExpression>>& result, + value::SlotId slot, + std::unique_ptr<EExpression> expr, + Ts&&... rest) { + result.emplace(slot, std::move(expr)); + makeEM_unwind(result, std::forward<Ts>(rest)...); } } // namespace detail @@ -398,7 +386,7 @@ auto makeEM(Ts&&... pack) { value::SlotMap<std::unique_ptr<EExpression>> result; if constexpr (sizeof...(pack) > 0) { result.reserve(sizeof...(Ts) / 2); - detail::makeSlotExprPairHelper(result, std::forward<Ts>(pack)...); + detail::makeEM_unwind(result, std::forward<Ts>(pack)...); } return result; } @@ -411,16 +399,6 @@ auto makeSV(Args&&... args) { return v; } -template <typename... Ts> -auto makeSlotExprPairVec(Ts&&... pack) { - SlotExprPairVector v; - if constexpr (sizeof...(pack) > 0) { - v.reserve(sizeof...(Ts) / 2); - detail::makeSlotExprPairHelper(v, std::forward<Ts>(pack)...); - } - return v; -} - /** * This is a constant expression. It assumes the ownership of the input constant. */ diff --git a/src/mongo/db/exec/sbe/expressions/sbe_set_expressions_test.cpp b/src/mongo/db/exec/sbe/expressions/sbe_set_expressions_test.cpp index 279f7a287b4..30eb61a7b2d 100644 --- a/src/mongo/db/exec/sbe/expressions/sbe_set_expressions_test.cpp +++ b/src/mongo/db/exec/sbe/expressions/sbe_set_expressions_test.cpp @@ -28,7 +28,6 @@ */ #include "mongo/db/exec/sbe/expression_test_base.h" -#include "mongo/db/query/sbe_stage_builder_helpers.h" namespace mongo::sbe { @@ -94,35 +93,6 @@ TEST_F(SBEBuiltinSetOpTest, ReturnsNothingSetUnion) { runAndAssertNothing(compiledExpr.get()); } -TEST_F(SBEBuiltinSetOpTest, AggSetUnion) { - value::OwnedValueAccessor aggAccessor, inputAccessor; - auto inputSlot = bindAccessor(&inputAccessor); - auto setUnionExpr = - stage_builder::makeFunction("aggSetUnion", stage_builder::makeVariable(inputSlot)); - auto compiledExpr = compileAggExpression(*setUnionExpr, &aggAccessor); - - auto [arrTag1, arrVal1] = makeArray(BSON_ARRAY(1 << 2)); - inputAccessor.reset(arrTag1, arrVal1); - auto [resTag1, resVal1] = makeArraySet(BSON_ARRAY(1 << 2)); - runAndAssertExpression(compiledExpr.get(), {resTag1, resVal1}); - aggAccessor.reset(resTag1, resVal1); - - auto [arrTag2, arrVal2] = makeArraySet(BSON_ARRAY(1 << 3 << 2 << 6)); - inputAccessor.reset(arrTag2, arrVal2); - auto [resTag2, resVal2] = makeArraySet(BSON_ARRAY(1 << 2 << 3 << 6)); - runAndAssertExpression(compiledExpr.get(), {resTag2, resVal2}); - aggAccessor.reset(resTag2, resVal2); - - auto [arrTag3, arrVal3] = makeArray(BSONArray{}); - inputAccessor.reset(arrTag3, arrVal3); - auto [resTag3, resVal3] = makeArraySet(BSON_ARRAY(1 << 2 << 3 << 6)); - runAndAssertExpression(compiledExpr.get(), {resTag3, resVal3}); - aggAccessor.reset(resTag3, resVal3); - - inputAccessor.reset(value::TypeTags::Nothing, 0); - runAndAssertNothing(compiledExpr.get()); -} - TEST_F(SBEBuiltinSetOpTest, ComputesSetIntersection) { value::OwnedValueAccessor slotAccessor1, slotAccessor2; auto arrSlot1 = bindAccessor(&slotAccessor1); diff --git a/src/mongo/db/exec/sbe/sbe_hash_agg_test.cpp b/src/mongo/db/exec/sbe/sbe_hash_agg_test.cpp index 89244fd4589..87fc8dbd1f2 100644 --- a/src/mongo/db/exec/sbe/sbe_hash_agg_test.cpp +++ b/src/mongo/db/exec/sbe/sbe_hash_agg_test.cpp @@ -69,23 +69,18 @@ void HashAggStageTest::performHashAggWithSpillChecking( auto makeStageFn = [this, collatorSlot, shouldUseCollator, shouldSpill]( value::SlotId scanSlot, std::unique_ptr<PlanStage> scanStage) { auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction("sum", - makeE<EConstant>(value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction("sum", + makeE<EConstant>(value::TypeTags::NumberInt64, + value::bitcastFrom<int64_t>(1)))), makeSV(), true, boost::optional<value::SlotId>{shouldUseCollator, collatorSlot}, shouldSpill, - makeSlotExprPairVec( - spillSlot, - stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); return std::make_pair(countsSlot, std::move(hashAggStage)); @@ -171,21 +166,20 @@ TEST_F(HashAggStageTest, HashAggMinMaxTest) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(), - makeSlotExprPairVec(minSlot, - stage_builder::makeFunction("min", makeE<EVariable>(scanSlot)), - maxSlot, - stage_builder::makeFunction("max", makeE<EVariable>(scanSlot)), - collMinSlot, - stage_builder::makeFunction( - "collMin", collExpr->clone(), makeE<EVariable>(scanSlot)), - collMaxSlot, - stage_builder::makeFunction( - "collMax", collExpr->clone(), makeE<EVariable>(scanSlot))), + makeEM(minSlot, + stage_builder::makeFunction("min", makeE<EVariable>(scanSlot)), + maxSlot, + stage_builder::makeFunction("max", makeE<EVariable>(scanSlot)), + collMinSlot, + stage_builder::makeFunction( + "collMin", collExpr->clone(), makeE<EVariable>(scanSlot)), + collMaxSlot, + stage_builder::makeFunction( + "collMax", collExpr->clone(), makeE<EVariable>(scanSlot))), makeSV(), true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec() /* mergingExprs */, kEmptyPlanNodeId); auto outSlot = generateSlotId(); @@ -236,15 +230,13 @@ TEST_F(HashAggStageTest, HashAggAddToSetTest) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(), - makeSlotExprPairVec(hashAggSlot, - stage_builder::makeFunction("collAddToSet", - std::move(collExpr), - makeE<EVariable>(scanSlot))), + makeEM(hashAggSlot, + stage_builder::makeFunction( + "collAddToSet", std::move(collExpr), makeE<EVariable>(scanSlot))), makeSV(), true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec() /* mergingExprs */, kEmptyPlanNodeId); return std::make_pair(hashAggSlot, std::move(hashAggStage)); @@ -335,16 +327,14 @@ TEST_F(HashAggStageTest, HashAggSeekKeysTest) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction("sum", - makeE<EConstant>(value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction("sum", + makeE<EConstant>(value::TypeTags::NumberInt64, + value::bitcastFrom<int64_t>(1)))), makeSV(seekSlot), true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec() /* mergingExprs */, kEmptyPlanNodeId); return std::make_pair(countsSlot, std::move(hashAggStage)); @@ -397,21 +387,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpill) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -434,7 +420,6 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpill) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_FALSE(stats->usedDisk); - ASSERT_EQ(0, stats->numSpills); ASSERT_EQ(0, stats->spilledRecords); stage->close(); @@ -443,6 +428,7 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpill) { TEST_F(HashAggStageTest, HashAggBasicCountSpill) { // We estimate the size of result row like {int64, int64} at 50B. Set the memory threshold to // 64B so that exactly one row fits in memory. + const int expectedRowsToFitInMemory = 1; auto defaultInternalQuerySBEAggApproxMemoryUseInBytesBeforeSpill = internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.load(); internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.store(64); @@ -460,21 +446,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountSpill) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -497,14 +479,7 @@ TEST_F(HashAggStageTest, HashAggBasicCountSpill) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_TRUE(stats->usedDisk); - // Memory usage is estimated only every two rows at the most frequent. Also, we only start - // spilling after estimating that the memory budget is exceeded. These two factors result in - // fewer expected spills than there are input records, even though only one record fits in - // memory at a time. - ASSERT_EQ(stats->numSpills, 3); - // The input has one run of two consecutive values, so we expect to spill as many records as - // there are input values minus one. - ASSERT_EQ(stats->spilledRecords, 8); + ASSERT_EQ(results.size() - expectedRowsToFitInMemory, stats->spilledRecords); stage->close(); } @@ -538,21 +513,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillIfNoMemCheck) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -575,7 +546,6 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillIfNoMemCheck) { // Check that it did not spill. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_FALSE(stats->usedDisk); - ASSERT_EQ(0, stats->numSpills); ASSERT_EQ(0, stats->spilledRecords); stage->close(); @@ -584,6 +554,7 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillIfNoMemCheck) { TEST_F(HashAggStageTest, HashAggBasicCountSpillDouble) { // We estimate the size of result row like {double, int64} at 50B. Set the memory threshold to // 64B so that exactly one row fits in memory. + const int expectedRowsToFitInMemory = 1; auto defaultInternalQuerySBEAggApproxMemoryUseInBytesBeforeSpill = internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.load(); internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.store(64); @@ -601,21 +572,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountSpillDouble) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -638,14 +605,7 @@ TEST_F(HashAggStageTest, HashAggBasicCountSpillDouble) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_TRUE(stats->usedDisk); - // Memory usage is estimated only every two rows at the most frequent. Also, we only start - // spilling after estimating that the memory budget is exceeded. These two factors result in - // fewer expected spills than there are input records, even though only one record fits in - // memory at a time. - ASSERT_EQ(stats->numSpills, 3); - // The input has one run of two consecutive values, so we expect to spill as many records as - // there are input values minus one. - ASSERT_EQ(stats->spilledRecords, 8); + ASSERT_EQ(results.size() - expectedRowsToFitInMemory, stats->spilledRecords); stage->close(); } @@ -667,21 +627,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillWithNoGroupByDouble) { // Build a HashAggStage, with an empty group by slot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -702,7 +658,6 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillWithNoGroupByDouble) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_FALSE(stats->usedDisk); - ASSERT_EQ(0, stats->numSpills); ASSERT_EQ(0, stats->spilledRecords); stage->close(); @@ -711,6 +666,7 @@ TEST_F(HashAggStageTest, HashAggBasicCountNoSpillWithNoGroupByDouble) { TEST_F(HashAggStageTest, HashAggMultipleAccSpill) { // We estimate the size of result row like {double, int64} at 59B. Set the memory threshold to // 128B so that two rows fit in memory. + const int expectedRowsToFitInMemory = 2; auto defaultInternalQuerySBEAggApproxMemoryUseInBytesBeforeSpill = internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.load(); internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.store(128); @@ -729,27 +685,19 @@ TEST_F(HashAggStageTest, HashAggMultipleAccSpill) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); auto sumsSlot = generateSlotId(); - auto spillSlot1 = generateSlotId(); - auto spillSlot2 = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1))), - sumsSlot, - stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1))), + sumsSlot, + stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), makeSV(), // Seek slot true, boost::none, true /* allowDiskUse */, - makeSlotExprPairVec( - spillSlot1, - stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot1)), - spillSlot2, - stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot2))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -779,10 +727,7 @@ TEST_F(HashAggStageTest, HashAggMultipleAccSpill) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_TRUE(stats->usedDisk); - ASSERT_EQ(stats->numSpills, 3); - // The input has one run of two consecutive values, so we expect to spill as many records as - // there are input values minus one. - ASSERT_EQ(stats->spilledRecords, 8); + ASSERT_EQ(results.size() - expectedRowsToFitInMemory, stats->spilledRecords); stage->close(); } @@ -807,27 +752,19 @@ TEST_F(HashAggStageTest, HashAggMultipleAccSpillAllToDisk) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); auto sumsSlot = generateSlotId(); - auto spillSlot1 = generateSlotId(); - auto spillSlot2 = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1))), - sumsSlot, - stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1))), + sumsSlot, + stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), makeSV(), // Seek slot true, boost::none, true, // allowDiskUse=true - makeSlotExprPairVec( - spillSlot1, - stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot1)), - spillSlot2, - stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot2))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -857,9 +794,7 @@ TEST_F(HashAggStageTest, HashAggMultipleAccSpillAllToDisk) { // Check that the spilling behavior matches the expected. auto stats = static_cast<const HashAggStats*>(stage->getSpecificStats()); ASSERT_TRUE(stats->usedDisk); - // We expect each incoming value to result in a spill of a single record. - ASSERT_EQ(stats->numSpills, 9); - ASSERT_EQ(stats->spilledRecords, 9); + ASSERT_EQ(results.size(), stats->spilledRecords); stage->close(); } @@ -896,18 +831,14 @@ TEST_F(HashAggStageTest, HashAggSum10Groups) { // Build a HashAggStage, group by the scanSlot and compute a sum for each group. auto sumsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec(sumsSlot, - stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), + makeEM(sumsSlot, stage_builder::makeFunction("sum", makeE<EVariable>(scanSlot))), makeSV(), // Seek slot true, boost::none, true, // allowDiskUse=true - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. @@ -941,21 +872,17 @@ TEST_F(HashAggStageTest, HashAggBasicCountWithRecordIds) { // Build a HashAggStage, group by the scanSlot and compute a simple count. auto countsSlot = generateSlotId(); - auto spillSlot = generateSlotId(); auto stage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), makeSV(), // Seek slot true, boost::none, true, // allowDiskUse=true - makeSlotExprPairVec( - spillSlot, stage_builder::makeFunction("sum", stage_builder::makeVariable(spillSlot))), kEmptyPlanNodeId); // Prepare the tree and get the 'SlotAccessor' for the output slot. diff --git a/src/mongo/db/exec/sbe/sbe_plan_size_test.cpp b/src/mongo/db/exec/sbe/sbe_plan_size_test.cpp index f62b8a6229c..191f0ffe562 100644 --- a/src/mongo/db/exec/sbe/sbe_plan_size_test.cpp +++ b/src/mongo/db/exec/sbe/sbe_plan_size_test.cpp @@ -139,12 +139,11 @@ TEST_F(PlanSizeTest, Filter) { TEST_F(PlanSizeTest, HashAgg) { auto stage = makeS<HashAggStage>(mockS(), mockSV(), - makeSlotExprPairVec(generateSlotId(), mockE()), + makeEM(generateSlotId(), mockE()), makeSV(), true, generateSlotId(), false, - makeSlotExprPairVec(), kEmptyPlanNodeId); assertPlanSize(*stage); } @@ -169,7 +168,6 @@ TEST_F(PlanSizeTest, IndexScan) { generateSlotId(), generateSlotId(), generateSlotId(), - generateSlotId(), IndexKeysInclusionSet(1), mockSV(), generateSlotId(), diff --git a/src/mongo/db/exec/sbe/sbe_plan_stage_test.cpp b/src/mongo/db/exec/sbe/sbe_plan_stage_test.cpp index 4f3e6d44372..77b1997bdee 100644 --- a/src/mongo/db/exec/sbe/sbe_plan_stage_test.cpp +++ b/src/mongo/db/exec/sbe/sbe_plan_stage_test.cpp @@ -66,12 +66,7 @@ PlanStageTestFixture::generateVirtualScanMulti(int32_t numSlots, const BSONArray } void PlanStageTestFixture::prepareTree(CompileCtx* ctx, PlanStage* root) { - // We want to avoid recursive locking since this results in yield plans that don't yield when - // they should. - boost::optional<Lock::GlobalLock> globalLock; - if (!opCtx()->lockState()->isLocked()) { - globalLock.emplace(opCtx(), MODE_IS); - } + Lock::GlobalLock globalLock{opCtx(), MODE_IS}; root->attachToOperationContext(opCtx()); root->prepare(*ctx); root->open(false); diff --git a/src/mongo/db/exec/sbe/sbe_trial_run_tracker_test.cpp b/src/mongo/db/exec/sbe/sbe_trial_run_tracker_test.cpp index 57d3ff4e05f..54fadbe1f15 100644 --- a/src/mongo/db/exec/sbe/sbe_trial_run_tracker_test.cpp +++ b/src/mongo/db/exec/sbe/sbe_trial_run_tracker_test.cpp @@ -141,16 +141,14 @@ TEST_F(TrialRunTrackerTest, TrialEndsDuringOpenPhaseOfBlockingStage) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), - makeSV(), /* Seek slot */ + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeSV(), // Seek slot true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec(), /* mergingExprs */ kEmptyPlanNodeId); auto tracker = std::make_unique<TrialRunTracker>(numResultsLimit, size_t{0}); @@ -212,16 +210,14 @@ TEST_F(TrialRunTrackerTest, OnlyDeepestNestedBlockingStageHasTrialRunTracker) { auto hashAggStage = makeS<HashAggStage>( std::move(unionStage), makeSV(unionSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction( - "sum", - makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), - makeSV(), /* Seek slot */ + makeEM(countsSlot, + stage_builder::makeFunction( + "sum", + makeE<EConstant>(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(1)))), + makeSV(), // Seek slot true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec(), /* mergingExprs */ kEmptyPlanNodeId); hashAggStage->prepare(*ctx); @@ -281,16 +277,14 @@ TEST_F(TrialRunTrackerTest, SiblingBlockingStagesBothGetTrialRunTracker) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction("sum", - makeE<EConstant>(value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(1)))), - makeSV(), /* Seek slot */ + makeEM(countsSlot, + stage_builder::makeFunction("sum", + makeE<EConstant>(value::TypeTags::NumberInt64, + value::bitcastFrom<int64_t>(1)))), + makeSV(), // Seek slot true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec(), /* mergingExprs */ kEmptyPlanNodeId); return std::make_pair(countsSlot, std::move(hashAggStage)); @@ -413,16 +407,14 @@ TEST_F(TrialRunTrackerTest, DisablingTrackingForAChildStagePreventsEarlyExit) { auto hashAggStage = makeS<HashAggStage>( std::move(scanStage), makeSV(scanSlot), - makeSlotExprPairVec( - countsSlot, - stage_builder::makeFunction("sum", - makeE<EConstant>(value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(1)))), - makeSV(), /* Seek slot */ + makeEM(countsSlot, + stage_builder::makeFunction("sum", + makeE<EConstant>(value::TypeTags::NumberInt64, + value::bitcastFrom<int64_t>(1)))), + makeSV(), // Seek slot true, boost::none, false /* allowDiskUse */, - makeSlotExprPairVec(), /* mergingExprs */ kEmptyPlanNodeId); return std::make_pair(countsSlot, std::move(hashAggStage)); diff --git a/src/mongo/db/exec/sbe/size_estimator.h b/src/mongo/db/exec/sbe/size_estimator.h index bbb92328331..fb6684eea52 100644 --- a/src/mongo/db/exec/sbe/size_estimator.h +++ b/src/mongo/db/exec/sbe/size_estimator.h @@ -92,11 +92,6 @@ inline size_t estimate(const S& stats) { return stats.estimateObjectSizeInBytes() - sizeof(S); } -template <typename A, typename B> -inline size_t estimate(const std::pair<A, B>& pair) { - return estimate(pair.first) + estimate(pair.second); -} - // Calculate the size of the inlined vector's elements. template <typename T, size_t N, typename A> size_t estimate(const absl::InlinedVector<T, N, A>& vector) { diff --git a/src/mongo/db/exec/sbe/stages/branch.cpp b/src/mongo/db/exec/sbe/stages/branch.cpp index 1e8809f0858..bec12b12ee2 100644 --- a/src/mongo/db/exec/sbe/stages/branch.cpp +++ b/src/mongo/db/exec/sbe/stages/branch.cpp @@ -70,29 +70,31 @@ void BranchStage::prepare(CompileCtx& ctx) { _children[0]->prepare(ctx); _children[1]->prepare(ctx); - // All of the slots listed in '_outputVals' must be unique. for (size_t idx = 0; idx < _outputVals.size(); ++idx) { - auto slot = _outputVals[idx]; - auto [_, inserted] = dupCheck.insert(slot); - uassert(4822831, str::stream() << "duplicate field: " << slot, inserted); - } + std::vector<value::SlotAccessor*> accessors; + accessors.reserve(2); - for (size_t idx = 0; idx < _outputVals.size(); ++idx) { - auto thenSlot = _inputThenVals[idx]; - auto elseSlot = _inputElseVals[idx]; + { + auto slot = _inputThenVals[idx]; + auto [it, inserted] = dupCheck.insert(slot); + uassert(4822829, str::stream() << "duplicate field: " << slot, inserted); - // Slots listed in '_inputThenVals' and '_inputElseVals' may not appear in '_outputVals'. - bool thenSlotFound = dupCheck.count(thenSlot); - bool elseSlotFound = dupCheck.count(elseSlot); - uassert(4822829, str::stream() << "duplicate field: " << thenSlot, !thenSlotFound); - uassert(4822830, str::stream() << "duplicate field: " << elseSlot, !elseSlotFound); + accessors.emplace_back(_children[0]->getAccessor(ctx, slot)); + } + { + auto slot = _inputElseVals[idx]; + auto [it, inserted] = dupCheck.insert(slot); + uassert(4822830, str::stream() << "duplicate field: " << slot, inserted); - std::vector<value::SlotAccessor*> accessors; - accessors.reserve(2); - accessors.emplace_back(_children[0]->getAccessor(ctx, thenSlot)); - accessors.emplace_back(_children[1]->getAccessor(ctx, elseSlot)); + accessors.emplace_back(_children[1]->getAccessor(ctx, slot)); + } + { + auto slot = _outputVals[idx]; + auto [it, inserted] = dupCheck.insert(slot); + uassert(4822831, str::stream() << "duplicate field: " << slot, inserted); - _outValueAccessors.emplace_back(value::SwitchAccessor{std::move(accessors)}); + _outValueAccessors.emplace_back(value::SwitchAccessor{std::move(accessors)}); + } } // compile filter diff --git a/src/mongo/db/exec/sbe/stages/collection_helpers.h b/src/mongo/db/exec/sbe/stages/collection_helpers.h index 7471763a44a..4116f2980ff 100644 --- a/src/mongo/db/exec/sbe/stages/collection_helpers.h +++ b/src/mongo/db/exec/sbe/stages/collection_helpers.h @@ -40,7 +40,6 @@ namespace mongo::sbe { * A callback which gets called whenever a SCAN stage asks an underlying index scan for a result. */ using IndexKeyConsistencyCheckCallback = std::function<bool(OperationContext* opCtx, - StringMap<const IndexCatalogEntry*>&, value::SlotAccessor* snapshotIdAccessor, value::SlotAccessor* indexIdAccessor, value::SlotAccessor* indexKeyAccessor, diff --git a/src/mongo/db/exec/sbe/stages/hash_agg.cpp b/src/mongo/db/exec/sbe/stages/hash_agg.cpp index 2514dedf1b0..14f40afeaa9 100644 --- a/src/mongo/db/exec/sbe/stages/hash_agg.cpp +++ b/src/mongo/db/exec/sbe/stages/hash_agg.cpp @@ -27,67 +27,47 @@ * it in the license file. */ -#include "mongo/db/exec/sbe/stages/hash_agg.h" +#include "mongo/platform/basic.h" #include "mongo/db/concurrency/d_concurrency.h" -#include "mongo/db/exec/sbe/size_estimator.h" +#include "mongo/db/concurrency/write_conflict_exception.h" +#include "mongo/db/exec/sbe/stages/hash_agg.h" #include "mongo/db/exec/sbe/util/spilling.h" -#include "mongo/db/stats/resource_consumption_metrics.h" #include "mongo/db/storage/kv/kv_engine.h" #include "mongo/db/storage/storage_engine.h" #include "mongo/util/str.h" +#include "mongo/db/exec/sbe/size_estimator.h" + namespace mongo { namespace sbe { HashAggStage::HashAggStage(std::unique_ptr<PlanStage> input, value::SlotVector gbs, - SlotExprPairVector aggs, + value::SlotMap<std::unique_ptr<EExpression>> aggs, value::SlotVector seekKeysSlots, bool optimizedClose, boost::optional<value::SlotId> collatorSlot, bool allowDiskUse, - SlotExprPairVector mergingExprs, - PlanNodeId planNodeId, - bool forceIncreasedSpilling) + PlanNodeId planNodeId) : PlanStage("group"_sd, planNodeId), _gbs(std::move(gbs)), _aggs(std::move(aggs)), _collatorSlot(collatorSlot), _allowDiskUse(allowDiskUse), _seekKeysSlots(std::move(seekKeysSlots)), - _optimizedClose(optimizedClose), - _mergingExprs(std::move(mergingExprs)), - _forceIncreasedSpilling(forceIncreasedSpilling) { + _optimizedClose(optimizedClose) { _children.emplace_back(std::move(input)); invariant(_seekKeysSlots.empty() || _seekKeysSlots.size() == _gbs.size()); tassert(5843100, "HashAgg stage was given optimizedClose=false and seek keys", _seekKeysSlots.empty() || _optimizedClose); - - if (_allowDiskUse) { - tassert(7039549, - "disk use enabled for HashAggStage but incorrect number of merging expresssions", - _aggs.size() == _mergingExprs.size()); - } - - if (_forceIncreasedSpilling) { - tassert(7039554, "'forceIncreasedSpilling' set but disk use not allowed", _allowDiskUse); - } } std::unique_ptr<PlanStage> HashAggStage::clone() const { - SlotExprPairVector aggs; - aggs.reserve(_aggs.size()); + value::SlotMap<std::unique_ptr<EExpression>> aggs; for (auto& [k, v] : _aggs) { - aggs.push_back({k, v->clone()}); + aggs.emplace(k, v->clone()); } - - SlotExprPairVector mergingExprsClone; - mergingExprsClone.reserve(_mergingExprs.size()); - for (auto&& [k, v] : _mergingExprs) { - mergingExprsClone.push_back({k, v->clone()}); - } - return std::make_unique<HashAggStage>(_children[0]->clone(), _gbs, std::move(aggs), @@ -95,34 +75,24 @@ std::unique_ptr<PlanStage> HashAggStage::clone() const { _optimizedClose, _collatorSlot, _allowDiskUse, - std::move(mergingExprsClone), - _commonStats.nodeId, - _forceIncreasedSpilling); + _commonStats.nodeId); } void HashAggStage::doSaveState(bool relinquishCursor) { if (relinquishCursor) { if (_rsCursor) { - _recordStore->saveCursor(_opCtx, _rsCursor); + _rsCursor->save(); } } if (_rsCursor) { _rsCursor->setSaveStorageCursorOnDetachFromOperationContext(!relinquishCursor); } - - if (_recordStore) { - _recordStore->saveState(); - } } void HashAggStage::doRestoreState(bool relinquishCursor) { invariant(_opCtx); - if (_recordStore) { - _recordStore->restoreState(); - } - if (_rsCursor && relinquishCursor) { - auto couldRestore = _recordStore->restoreCursor(_opCtx, _rsCursor); + auto couldRestore = _rsCursor->restore(); uassert(6196500, "HashAggStage could not restore cursor", couldRestore); } } @@ -150,36 +120,34 @@ void HashAggStage::prepare(CompileCtx& ctx) { } value::SlotSet dupCheck; - auto throwIfDupSlot = [&dupCheck](value::SlotId slot) { - auto [_, inserted] = dupCheck.emplace(slot); - tassert(7039551, "duplicate slot id", inserted); - }; - size_t counter = 0; // Process group by columns. for (auto& slot : _gbs) { - throwIfDupSlot(slot); + auto [it, inserted] = dupCheck.emplace(slot); + uassert(4822827, str::stream() << "duplicate field: " << slot, inserted); _inKeyAccessors.emplace_back(_children[0]->getAccessor(ctx, slot)); - // Construct accessors for obtaining the key values from either the hash table '_ht' or the - // '_recordStore'. + // Construct accessors for the key to be processed from either the '_ht' or the + // '_recordStore'. Before the memory limit is reached the '_outHashKeyAccessors' will carry + // the group-by keys, otherwise the '_outRecordStoreKeyAccessors' will carry the group-by + // keys. _outHashKeyAccessors.emplace_back(std::make_unique<HashKeyAccessor>(_htIt, counter)); _outRecordStoreKeyAccessors.emplace_back( - std::make_unique<value::MaterializedSingleRowAccessor>(_outKeyRowRecordStore, counter)); + std::make_unique<value::MaterializedSingleRowAccessor>(_aggKeyRecordStore, counter)); + + counter++; - // A 'SwitchAccessor' is used to point the '_outKeyAccessors' to the key coming from the - // '_ht' or the '_recordStore' when draining the HashAgg stage in getNext(). If no spilling - // occurred, the keys will be obtained from the hash table. If spilling kicked in, then all - // of the data is written out to the record store, so the 'SwitchAccessor' is reconfigured - // to obtain all of the keys from the spill table. + // A SwitchAccessor is used to point the '_outKeyAccessors' to the key coming from the '_ht' + // or the '_recordStore' when draining the HashAgg stage in getNext. The group-by key will + // either be in the '_ht' or the '_recordStore' if the key lives in memory, or if the key + // has been spilled to disk, respectively. The SwitchAccessor allows toggling between the + // two so the parent stage can read it through the '_outAccessors'. _outKeyAccessors.emplace_back( std::make_unique<value::SwitchAccessor>(std::vector<value::SlotAccessor*>{ _outHashKeyAccessors.back().get(), _outRecordStoreKeyAccessors.back().get()})); _outAccessors[slot] = _outKeyAccessors.back().get(); - - ++counter; } // Process seek keys (if any). The keys must come from outside of the subtree (by definition) so @@ -190,18 +158,26 @@ void HashAggStage::prepare(CompileCtx& ctx) { counter = 0; for (auto& [slot, expr] : _aggs) { - throwIfDupSlot(slot); - - // Just like with the output accessors for the keys, we construct output accessors for the - // aggregate values that read from either the hash table '_ht' or the '_recordStore'. + auto [it, inserted] = dupCheck.emplace(slot); + // Some compilers do not allow to capture local bindings by lambda functions (the one + // is used implicitly in uassert below), so we need a local variable to construct an + // error message. + const auto slotId = slot; + uassert(4822828, str::stream() << "duplicate field: " << slotId, inserted); + + // Construct accessors for the agg state to be processed from either the '_ht' or the + // '_recordStore' by the SwitchAccessor owned by '_outAggAccessors' below. _outRecordStoreAggAccessors.emplace_back( - std::make_unique<value::MaterializedSingleRowAccessor>(_outAggRowRecordStore, counter)); + std::make_unique<value::MaterializedSingleRowAccessor>(_aggValueRecordStore, counter)); _outHashAggAccessors.emplace_back(std::make_unique<HashAggAccessor>(_htIt, counter)); - - // A 'SwitchAccessor' is used to toggle the '_outAggAccessors' between the '_ht' and the - // '_recordStore'. Just like the key values, the aggregate values are always obtained from - // the hash table if no spilling occurred and are always obtained from the record store if - // spilling occurred. + counter++; + + // A SwitchAccessor is used to toggle the '_outAggAccessors' between the '_ht' and the + // '_recordStore' when updating the agg state via the bytecode. By compiling the agg + // EExpressions with a SwitchAccessor we can load the agg value into the memory of + // '_aggValueRecordStore' if the value comes from the '_recordStore' or we can use the + // agg value referenced through '_htIt' and run the bytecode to mutate the value through the + // SwitchAccessor. _outAggAccessors.emplace_back( std::make_unique<value::SwitchAccessor>(std::vector<value::SlotAccessor*>{ _outHashAggAccessors.back().get(), _outRecordStoreAggAccessors.back().get()})); @@ -211,32 +187,10 @@ void HashAggStage::prepare(CompileCtx& ctx) { ctx.root = this; ctx.aggExpression = true; ctx.accumulator = _outAggAccessors.back().get(); + _aggCodes.emplace_back(expr->compile(ctx)); ctx.aggExpression = false; - - ++counter; - } - - // If disk use is allowed, then we need to compile the merging expressions as well. - if (_allowDiskUse) { - counter = 0; - for (auto&& [spillSlot, mergingExpr] : _mergingExprs) { - throwIfDupSlot(spillSlot); - - _spilledAggsAccessors.push_back( - std::make_unique<value::MaterializedSingleRowAccessor>(_spilledAggRow, counter)); - _spilledAggsAccessorMap[spillSlot] = _spilledAggsAccessors.back().get(); - - ctx.root = this; - ctx.aggExpression = true; - ctx.accumulator = _outAggAccessors[counter].get(); - _mergingExprCodes.emplace_back(mergingExpr->compile(ctx)); - ctx.aggExpression = false; - - ++counter; - } } - _compiled = true; } @@ -246,15 +200,6 @@ value::SlotAccessor* HashAggStage::getAccessor(CompileCtx& ctx, value::SlotId sl return it->second; } } else { - // The slots into which we read spilled partial aggregates, accessible via - // '_spilledAggsAccessors', should only be visible to this stage. They are used internally - // when merging spilled partial aggregates and should never be read by ancestor stages. - // Therefore, they are only made visible when this stage is in the process of compiling - // itself. - if (auto it = _spilledAggsAccessorMap.find(slot); it != _spilledAggsAccessorMap.end()) { - return it->second; - } - return _children[0]->getAccessor(ctx, slot); } @@ -270,117 +215,99 @@ void HashAggStage::makeTemporaryRecordStore() { "No storage engine so HashAggStage cannot spill to disk", _opCtx->getServiceContext()->getStorageEngine()); assertIgnorePrepareConflictsBehavior(_opCtx); - _recordStore = std::make_unique<SpillingStore>(_opCtx); + _recordStore = _opCtx->getServiceContext()->getStorageEngine()->makeTemporaryRecordStore( + _opCtx, KeyFormat::String); _specificStats.usedDisk = true; } void HashAggStage::spillRowToDisk(const value::MaterializedRow& key, const value::MaterializedRow& val) { - CollatorInterface* collator = nullptr; - if (_collatorAccessor) { - auto [colTag, colVal] = _collatorAccessor->getViewOfValue(); - collator = value::getCollatorView(colVal); - } - KeyString::Builder kb{KeyString::Version::kLatestVersion}; - // Serialize the key that will be used as the record id (rid) when storing the record in the - // record store. Use a keystring for the spilled entry's rid such that partial aggregates are - // guaranteed to have identical keystrings when their keys are equal with respect to the - // collation. - key.serializeIntoKeyString(kb, collator); - // Add a unique integer to the end of the key, since record ids must be unique. We want equal - // keys to be adjacent in the 'RecordStore' so that we can merge the partial aggregates with a - // single pass. - kb.appendNumberLong(_ridCounter++); - auto rid = RecordId(kb.getBuffer(), kb.getSize()); + key.serializeIntoKeyString(kb); + auto typeBits = kb.getTypeBits(); - if (collator) { - // The keystring cannot always be deserialized back to the original keys when a collation is - // in use, so we also store the unmodified key in the data part of the spilled record. - _recordStore->upsertToRecordStore(_opCtx, rid, key, val, false /*update*/); - } else { - auto typeBits = kb.getTypeBits(); - _recordStore->upsertToRecordStore(_opCtx, rid, val, typeBits, false /*update*/); - } + auto rid = RecordId(kb.getBuffer(), kb.getSize()); + boost::optional<value::MaterializedRow> valFromRs = + readFromRecordStore(_opCtx, _recordStore->rs(), rid); + tassert(6031100, "Spilling a row doesn't support updating it in the store.", !valFromRs); - _specificStats.spilledRecords++; + spillValueToDisk(rid, val, typeBits, false /*update*/); } -void HashAggStage::spill(MemoryCheckData& mcd) { - uassert(ErrorCodes::QueryExceededMemoryLimitNoDiskUseAllowed, - "Exceeded memory limit for $group, but didn't allow external spilling;" - " pass allowDiskUse:true to opt in", - _allowDiskUse); - - // Since we flush the entire hash table to disk, we also clear any state related to estimating - // memory consumption. - mcd.reset(); - - if (!_recordStore) { - makeTemporaryRecordStore(); - } - - for (auto&& it : *_ht) { - spillRowToDisk(it.first, it.second); +void HashAggStage::spillValueToDisk(const RecordId& key, + const value::MaterializedRow& val, + const KeyString::TypeBits& typeBits, + bool update) { + auto nBytes = upsertToRecordStore(_opCtx, _recordStore->rs(), key, val, typeBits, update); + if (!update) { + _specificStats.spilledRecords++; } - - auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx); - // We're not actually doing any sorting here or using the 'Sorter' class, but for the purposes - // of $operationMetrics we incorporate the number of spilled records into the "keysSorted" - // metric. Similarly, "sorterSpills" despite the name counts the number of individual spill - // events. - metricsCollector.incrementKeysSorted(_ht->size()); - metricsCollector.incrementSorterSpills(1); - - _ht->clear(); - - ++_specificStats.numSpills; + _specificStats.lastSpilledRecordSize = nBytes; } // Checks memory usage. Ideally, we'd want to know the exact size of already accumulated data, but // we cannot, so we estimate it based on the last updated/inserted row, if we have one, or the first // row in the '_ht' table. If the estimated memory usage exceeds the allowed, this method initiates -// spilling. +// spilling (if haven't been done yet) and evicts some records from the '_ht' table into the temp +// store to keep the memory usage under the limit. void HashAggStage::checkMemoryUsageAndSpillIfNecessary(MemoryCheckData& mcd) { - invariant(!_ht->empty()); + // The '_ht' table might become empty in the degenerate case when all rows had to be evicted to + // meet the memory constraint during a previous check -- we don't need to keep checking memory + // usage in this case because the table will never get new rows. + if (_ht->empty()) { + return; + } // If the group-by key is empty we will only ever aggregate into a single row so no sense in - // spilling. + // spilling since we will just be moving a single row back and forth from disk to main memory. if (_inKeyAccessors.size() == 0) { return; } mcd.memoryCheckpointCounter++; - if (mcd.memoryCheckpointCounter < mcd.nextMemoryCheckpoint) { - // We haven't reached the next checkpoint at which we estimate memory usage and decide if we - // should spill. - return; - } - - const long estimatedRowSize = - _htIt->first.memUsageForSorter() + _htIt->second.memUsageForSorter(); - long long estimatedTotalSize = _ht->size() * estimatedRowSize; - - if (estimatedTotalSize >= _approxMemoryUseInBytesBeforeSpill) { - spill(mcd); - } else { - // Calculate the next memory checkpoint. We estimate it based on the prior growth of the - // '_ht' and the remaining available memory. If 'estimatedGainPerChildAdvance' suggests that - // the hash table is growing, then the checkpoint is estimated as some configurable - // percentage of the number of additional input rows that we would have to process to - // consume the remaining memory. On the other hand, a value of 'estimtedGainPerChildAdvance' - // close to zero indicates a stable hash stable size, in which case we can delay the next - // check progressively. + if (mcd.memoryCheckpointCounter >= mcd.nextMemoryCheckpoint) { + if (_htIt == _ht->end()) { + _htIt = _ht->begin(); + } + const long estimatedRowSize = + _htIt->first.memUsageForSorter() + _htIt->second.memUsageForSorter(); + long long estimatedTotalSize = _ht->size() * estimatedRowSize; const double estimatedGainPerChildAdvance = (static_cast<double>(estimatedTotalSize - mcd.lastEstimatedMemoryUsage) / mcd.memoryCheckpointCounter); + if (estimatedTotalSize >= _approxMemoryUseInBytesBeforeSpill) { + uassert(ErrorCodes::QueryExceededMemoryLimitNoDiskUseAllowed, + "Exceeded memory limit for $group, but didn't allow external spilling." + " Pass allowDiskUse:true to opt in.", + _allowDiskUse); + if (!_recordStore) { + makeTemporaryRecordStore(); + } + + // Evict enough rows into the temporary store to drop below the memory constraint. + const long rowsToEvictCount = + 1 + (estimatedTotalSize - _approxMemoryUseInBytesBeforeSpill) / estimatedRowSize; + for (long i = 0; !_ht->empty() && i < rowsToEvictCount; i++) { + spillRowToDisk(_htIt->first, _htIt->second); + _ht->erase(_htIt); + _htIt = _ht->begin(); + } + estimatedTotalSize = _ht->size() * estimatedRowSize; + } + + // Calculate the next memory checkpoint. We estimate it based on the prior growth of the + // '_ht' and the remaining available memory. We have to keep doing this even after starting + // to spill because some accumulators can grow in size inside '_ht' (with no bounds). + // Value of 'estimatedGainPerChildAdvance' can be negative if the previous checkpoint + // evicted any records. And a value close to zero indicates a stable size of '_ht' so can + // delay the next check progressively. const long nextCheckpointCandidate = (estimatedGainPerChildAdvance > 0.1) ? mcd.checkpointMargin * (_approxMemoryUseInBytesBeforeSpill - estimatedTotalSize) / estimatedGainPerChildAdvance - : mcd.nextMemoryCheckpoint * 2; - + : (estimatedGainPerChildAdvance < -0.1) ? mcd.atMostCheckFrequency + : mcd.nextMemoryCheckpoint * 2; mcd.nextMemoryCheckpoint = std::min<long>(mcd.memoryCheckFrequency, std::max<long>(mcd.atMostCheckFrequency, nextCheckpointCandidate)); @@ -406,30 +333,17 @@ void HashAggStage::open(bool reOpen) { 5402503, "collatorSlot must be of collator type", tag == value::TypeTags::collator); auto collatorView = value::getCollatorView(collatorVal); const value::MaterializedRowHasher hasher(collatorView); - _keyEq = value::MaterializedRowEq(collatorView); - _ht.emplace(0, hasher, _keyEq); + const value::MaterializedRowEq equator(collatorView); + _ht.emplace(0, hasher, equator); } else { _ht.emplace(); } _seekKeys.resize(_seekKeysAccessors.size()); - // Reset state since this stage may have been previously opened. - for (auto&& accessor : _outKeyAccessors) { - accessor->setIndex(0); - } - for (auto&& accessor : _outAggAccessors) { - accessor->setIndex(0); - } - if (_recordStore) { - _recordStore->resetCursor(_opCtx, _rsCursor); - } - _recordStore.reset(); - _outKeyRowRecordStore = {0}; - _outAggRowRecordStore = {0}; - _spilledAggRow = {0}; - _stashedNextRow = {0, 0}; - + // A default value for spilling a key to the record store. + value::MaterializedRow defaultVal{_outAggAccessors.size()}; + bool updateAggStateHt = false; MemoryCheckData memoryCheckData; while (_children[0]->getNext() == PlanState::ADVANCED) { @@ -441,35 +355,57 @@ void HashAggStage::open(bool reOpen) { key.reset(idx++, false, tag, val); } - bool newKey = false; - _htIt = _ht->find(key); - if (_htIt == _ht->end()) { - // The key is not present in the hash table yet, so we insert it and initialize the - // corresponding accumulator. Note that as a future optimization, we could avoid - // doing a lookup both in the 'find()' call and in 'emplace()'. - newKey = true; + + if (_htIt = _ht->find(key); !_recordStore && _htIt == _ht->end()) { + // The memory limit hasn't been reached yet, insert a new key in '_ht' by copying + // the key. Note as a future optimization, we should avoid the lookup in the find() + // call and the emplace. key.makeOwned(); auto [it, _] = _ht->emplace(std::move(key), value::MaterializedRow{0}); + // Initialize accumulators. it->second.resize(_outAggAccessors.size()); _htIt = it; } - - // Accumulate state in '_ht'. - for (size_t idx = 0; idx < _outAggAccessors.size(); ++idx) { - auto [owned, tag, val] = _bytecode.run(_aggCodes[idx].get()); - _outHashAggAccessors[idx]->reset(owned, tag, val); - } - - if (_forceIncreasedSpilling && !newKey) { - // If configured to spill more than usual, we spill after seeing the same key twice. - spill(memoryCheckData); + updateAggStateHt = _htIt != _ht->end(); + + if (updateAggStateHt) { + // Accumulate state in '_ht' by pointing the '_outAggAccessors' the + // '_outHashAggAccessors'. + for (size_t idx = 0; idx < _outAggAccessors.size(); ++idx) { + _outAggAccessors[idx]->setIndex(0); + auto [owned, tag, val] = _bytecode.run(_aggCodes[idx].get()); + _outHashAggAccessors[idx]->reset(owned, tag, val); + } } else { - // Estimates how much memory is being used. If we estimate that the hash table - // exceeds the allotted memory budget, its contents are spilled to the - // '_recordStore' and '_ht' is cleared. - checkMemoryUsageAndSpillIfNecessary(memoryCheckData); + // The memory limit has been reached and the key wasn't in the '_ht' so we need + // to spill it to the '_recordStore'. + KeyString::Builder kb{KeyString::Version::kLatestVersion}; + // 'key' is moved only when 'updateAggStateHt' ends up "true", so it's safe to + // ignore the warning. + key.serializeIntoKeyString(kb); // NOLINT(bugprone-use-after-move) + auto typeBits = kb.getTypeBits(); + + auto rid = RecordId(kb.getBuffer(), kb.getSize()); + + boost::optional<value::MaterializedRow> valFromRs = + readFromRecordStore(_opCtx, _recordStore->rs(), rid); + if (!valFromRs) { + _aggValueRecordStore = defaultVal; + } else { + _aggValueRecordStore = *valFromRs; + } + + for (size_t idx = 0; idx < _outAggAccessors.size(); ++idx) { + _outAggAccessors[idx]->setIndex(1); + auto [owned, tag, val] = _bytecode.run(_aggCodes[idx].get()); + _aggValueRecordStore.reset(idx, owned, tag, val); + } + spillValueToDisk(rid, _aggValueRecordStore, typeBits, valFromRs ? true : false); } + // Estimates how much memory is being used and might start spilling. + checkMemoryUsageAndSpillIfNecessary(memoryCheckData); + if (_tracker && _tracker->trackProgress<TrialRunTracker::kNumResults>(1)) { // During trial runs, we want to limit the amount of work done by opening a blocking // stage, like this one. The blocking stage tracks the number of documents it has @@ -485,34 +421,9 @@ void HashAggStage::open(bool reOpen) { _children[0]->close(); _childOpened = false; } - - // If we spilled at any point while consuming the input, then do one final spill to write - // any leftover contents of '_ht' to the record store. That way, when recovering the input - // from the record store and merging partial aggregates we don't have to worry about the - // possibility of some of the data being in the hash table and some being in the record - // store. - if (_recordStore) { - if (!_ht->empty()) { - spill(memoryCheckData); - } - - _specificStats.spilledDataStorageSize = _recordStore->rs()->storageSize(_opCtx); - - // Establish a cursor, positioned at the beginning of the record store. - _rsCursor = _recordStore->getCursor(_opCtx); - - // Callers will be obtaining the results from the spill table, so set the - // 'SwitchAccessors' so that they refer to the rows recovered from the record store - // under the hood. - for (auto&& accessor : _outKeyAccessors) { - accessor->setIndex(1); - } - for (auto&& accessor : _outAggAccessors) { - accessor->setIndex(1); - } - } } + if (!_seekKeysAccessors.empty()) { // Copy keys in order to do the lookup. size_t idx = 0; @@ -523,103 +434,20 @@ void HashAggStage::open(bool reOpen) { } _htIt = _ht->end(); -} - -HashAggStage::SpilledRow HashAggStage::deserializeSpilledRecord(const Record& record, - BufBuilder& keyBuffer) { - // Read the values and type bits out of the value part of the record. - BufReader valReader(record.data.data(), record.data.size()); - - auto val = value::MaterializedRow::deserializeForSorter(valReader, {nullptr /*collator*/}); - auto typeBits = KeyString::TypeBits::fromBuffer(KeyString::Version::kLatestVersion, &valReader); - - keyBuffer.reset(); - auto key = value::MaterializedRow::deserializeFromKeyString( - decodeKeyString(record.id, typeBits), &keyBuffer, _gbs.size() /*numPrefixValuesToRead*/); - return {std::move(key), std::move(val)}; -} - -HashAggStage::SpilledRow HashAggStage::deserializeSpilledRecord(const Record& record, - const CollatorInterface& collator) { - BufReader valReader(record.data.data(), record.data.size()); - // When a collator has been defined, both the key and the value are stored in the data part of - // the record. First read the key and then read the value. - auto key = value::MaterializedRow::deserializeForSorter(valReader, {&collator}); - auto val = value::MaterializedRow::deserializeForSorter(valReader, {&collator}); - return {std::move(key), std::move(val)}; -} - -PlanState HashAggStage::getNextSpilled() { - CollatorInterface* collator = nullptr; - if (_collatorAccessor) { - auto [colTag, colVal] = _collatorAccessor->getViewOfValue(); - collator = value::getCollatorView(colVal); - } - - // Use the appropriate method to deserialize the record based on whether a collator is used. - auto recoverSpilledRecord = - [this](const Record& record, BufBuilder& keyBuffer, const CollatorInterface* collator) { - if (collator) { - return deserializeSpilledRecord(record, *collator); - } - return deserializeSpilledRecord(record, keyBuffer); - }; - - if (_stashedNextRow.first.isEmpty()) { - auto nextRecord = _rsCursor->next(); - if (!nextRecord) { - return trackPlanState(PlanState::IS_EOF); - } - - // We are just starting the process of merging the spilled file segments. - auto recoveredRow = recoverSpilledRecord(*nextRecord, _outKeyRowRSBuffer, collator); - - _outKeyRowRecordStore = std::move(recoveredRow.first); - _outAggRowRecordStore = std::move(recoveredRow.second); - } else { - // We peeked at the next key last time around. - _outKeyRowRSBuffer = std::move(_stashedKeyBuffer); - _outKeyRowRecordStore = std::move(_stashedNextRow.first); - _outAggRowRecordStore = std::move(_stashedNextRow.second); - // Clear the stashed row. - _stashedNextRow = {0, 0}; - } - - // Find additional partial aggregates for the same key and merge them in order to compute the - // final output. - for (auto nextRecord = _rsCursor->next(); nextRecord; nextRecord = _rsCursor->next()) { - auto recoveredRow = recoverSpilledRecord(*nextRecord, _stashedKeyBuffer, collator); - if (!_keyEq(recoveredRow.first, _outKeyRowRecordStore)) { - // The newly recovered spilled row belongs to a new key, so we're done merging partial - // aggregates for the old key. Save the new row for later and return advanced. - _stashedNextRow = std::move(recoveredRow); - return trackPlanState(PlanState::ADVANCED); - } - - // Merge in the new partial aggregate values. - _spilledAggRow = std::move(recoveredRow.second); - for (size_t idx = 0; idx < _mergingExprCodes.size(); ++idx) { - auto [owned, tag, val] = _bytecode.run(_mergingExprCodes[idx].get()); - _outRecordStoreAggAccessors[idx]->reset(owned, tag, val); - } + // Set the SwitchAccessors to point to the '_ht' so we can drain it first before draining the + // '_recordStore' in getNext(). + for (size_t idx = 0; idx < _outAggAccessors.size(); ++idx) { + _outAggAccessors[idx]->setIndex(0); } - - return trackPlanState(PlanState::ADVANCED); + _drainingRecordStore = false; } PlanState HashAggStage::getNext() { auto optTimer(getOptTimer(_opCtx)); - // If we've spilled, then we need to produce the output by merging the spilled segments from the - // spill file. - if (_recordStore) { - return getNextSpilled(); - } - - // We didn't spill. Obtain the next output row from the hash table. - if (_htIt == _ht->end()) { - // First invocation of getNext() after open(). + if (_htIt == _ht->end() && !_drainingRecordStore) { + // First invocation of getNext() after open() when not draining the '_recordStore'. if (!_seekKeysAccessors.empty()) { _htIt = _ht->find(_seekKeys); } else { @@ -628,13 +456,53 @@ PlanState HashAggStage::getNext() { } else if (!_seekKeysAccessors.empty()) { // Subsequent invocation with seek keys. Return only 1 single row (if any). _htIt = _ht->end(); - } else { + } else if (!_drainingRecordStore) { + // Returning the results of the entire hash table first before draining the '_recordStore'. ++_htIt; } - if (_htIt == _ht->end()) { - // The hash table has been drained (and we never spilled to disk) so we're done. + if (_htIt == _ht->end() && !_recordStore) { + // The hash table has been drained and nothing was spilled to disk. return trackPlanState(PlanState::IS_EOF); + } else if (_htIt != _ht->end()) { + // Drain the '_ht' on the next 'getNext()' call. + return trackPlanState(PlanState::ADVANCED); + } else if (_seekKeysAccessors.empty()) { + // A record store was created to spill to disk. Drain it then clean it up. + if (!_rsCursor) { + _rsCursor = _recordStore->rs()->getCursor(_opCtx); + } + auto nextRecord = _rsCursor->next(); + if (nextRecord) { + // Point the out accessors to the recordStore accessors to allow parent stages to read + // the agg state from the '_recordStore'. + if (!_drainingRecordStore) { + for (size_t i = 0; i < _outKeyAccessors.size(); ++i) { + _outKeyAccessors[i]->setIndex(1); + } + for (size_t i = 0; i < _outAggAccessors.size(); ++i) { + _outAggAccessors[i]->setIndex(1); + } + } + _drainingRecordStore = true; + + // Read the agg state value from the '_recordStore' and Reconstruct the key from the + // typeBits stored along side of the value. + BufReader valReader(nextRecord->data.data(), nextRecord->data.size()); + auto val = value::MaterializedRow::deserializeForSorter(valReader, {}); + auto typeBits = + KeyString::TypeBits::fromBuffer(KeyString::Version::kLatestVersion, &valReader); + _aggValueRecordStore = val; + + _aggKeyRSBuffer.reset(); + _aggKeyRecordStore = value::MaterializedRow::deserializeFromKeyString( + decodeKeyString(nextRecord->id, typeBits), &_aggKeyRSBuffer); + return trackPlanState(PlanState::ADVANCED); + } else { + _rsCursor.reset(); + _recordStore.reset(); + return trackPlanState(PlanState::IS_EOF); + } } else { return trackPlanState(PlanState::ADVANCED); } @@ -654,19 +522,11 @@ std::unique_ptr<PlanStageStats> HashAggStage::getStats(bool includeDebugInfo) co childrenBob.append(str::stream() << slot, printer.print(expr->debugPrint())); } } - - if (!_mergingExprs.empty()) { - BSONObjBuilder nestedBuilder{bob.subobjStart("mergingExprs")}; - for (auto&& [slot, expr] : _mergingExprs) { - nestedBuilder.append(str::stream() << slot, printer.print(expr->debugPrint())); - } - } - // Spilling stats. bob.appendBool("usedDisk", _specificStats.usedDisk); - bob.appendNumber("numSpills", _specificStats.numSpills); bob.appendNumber("spilledRecords", _specificStats.spilledRecords); - bob.appendNumber("spilledDataStorageSize", _specificStats.spilledDataStorageSize); + bob.appendNumber("spilledBytesApprox", + _specificStats.lastSpilledRecordSize * _specificStats.spilledRecords); ret->debugInfo = bob.obj(); } @@ -684,15 +544,11 @@ void HashAggStage::close() { trackClose(); _ht = boost::none; - if (_recordStore && _opCtx) { - _recordStore->resetCursor(_opCtx, _rsCursor); + if (_recordStore) { + // A record store was created to spill to disk. Clean it up. + _recordStore.reset(); + _drainingRecordStore = false; } - _rsCursor.reset(); - _recordStore.reset(); - _outKeyRowRecordStore = {0}; - _outAggRowRecordStore = {0}; - _spilledAggRow = {0}; - _stashedNextRow = {0, 0}; if (_childOpened) { _children[0]->close(); @@ -715,7 +571,7 @@ std::vector<DebugPrinter::Block> HashAggStage::debugPrint() const { ret.emplace_back(DebugPrinter::Block("[`")); bool first = true; - for (auto&& [slot, expr] : _aggs) { + value::orderedSlotMapTraverse(_aggs, [&](auto slot, auto&& expr) { if (!first) { ret.emplace_back(DebugPrinter::Block("`,")); } @@ -724,7 +580,7 @@ std::vector<DebugPrinter::Block> HashAggStage::debugPrint() const { ret.emplace_back("="); DebugPrinter::addBlocks(ret, expr->debugPrint()); first = false; - } + }); ret.emplace_back("`]"); if (!_seekKeysSlots.empty()) { @@ -739,28 +595,6 @@ std::vector<DebugPrinter::Block> HashAggStage::debugPrint() const { ret.emplace_back("`]"); } - if (!_mergingExprs.empty()) { - ret.emplace_back("spillSlots[`"); - for (size_t idx = 0; idx < _mergingExprs.size(); ++idx) { - if (idx) { - ret.emplace_back("`,"); - } - - DebugPrinter::addIdentifier(ret, _mergingExprs[idx].first); - } - ret.emplace_back("`]"); - - ret.emplace_back("mergingExprs[`"); - for (size_t idx = 0; idx < _mergingExprs.size(); ++idx) { - if (idx) { - ret.emplace_back("`,"); - } - - DebugPrinter::addBlocks(ret, _mergingExprs[idx].second->debugPrint()); - } - ret.emplace_back("`]"); - } - if (!_optimizedClose) { ret.emplace_back("reopen"); } @@ -781,7 +615,6 @@ size_t HashAggStage::estimateCompileTimeSize() const { size += size_estimator::estimate(_gbs); size += size_estimator::estimate(_aggs); size += size_estimator::estimate(_seekKeysSlots); - size += size_estimator::estimate(_mergingExprs); return size; } diff --git a/src/mongo/db/exec/sbe/stages/hash_agg.h b/src/mongo/db/exec/sbe/stages/hash_agg.h index 91f91051363..19fbca9d1c7 100644 --- a/src/mongo/db/exec/sbe/stages/hash_agg.h +++ b/src/mongo/db/exec/sbe/stages/hash_agg.h @@ -29,9 +29,10 @@ #pragma once +#include <unordered_map> + #include "mongo/db/exec/sbe/expressions/expression.h" #include "mongo/db/exec/sbe/stages/stages.h" -#include "mongo/db/exec/sbe/util/spilling.h" #include "mongo/db/exec/sbe/vm/vm.h" #include "mongo/db/query/query_knobs_gen.h" #include "mongo/db/storage/temporary_record_store.h" @@ -60,38 +61,21 @@ namespace sbe { * determining whether two group-by keys are equal. For instance, the plan may require us to do a * case-insensitive group on a string field. * - * The 'allowDiskUse' flag controls whether this stage can spill. If false and the memory budget is - * exhausted, this stage throws a query-fatal error with code - * 'QueryExceededMemoryLimitNoDiskUseAllowed'. If true, then spilling is possible and the caller - * must provide a vector of 'mergingExprs'. This is a vector of (slot, expression) pairs which is - * symmetrical with 'aggs'. The slots are only visible internally and are used to store partial - * aggregate values that have been recovered from the spill table. Each of the expressions is an agg - * function which merges the partial aggregate value from this slot into the final aggregate value. - * In the debug string output, the internal slots used to house the partial aggregates are printed - * as a list of "spillSlots" and the expressions are printed as a parallel list of "mergingExprs". - * - * If 'forcedIncreasedSpilling' is true, then this stage will spill frequently even if the memory - * limit is not reached. This is intended to be used in test contexts to exercise the otherwise - * infrequently used spilling logic. - * * Debug string representation: * - * group [<group by slots>] [slot_1 = expr_1, ..., slot_n = expr_n] [<seek slots>]? - * spillSlots[slot_1, ..., slot_n] mergingExprs[expr_1, ..., expr_n] reopen? collatorSlot? - * childStage + * group [<group by slots>] [slot_1 = expr_1, ..., slot_n = expr_n] [<seek slots>]? reopen? + * collatorSlot? childStage */ class HashAggStage final : public PlanStage { public: HashAggStage(std::unique_ptr<PlanStage> input, value::SlotVector gbs, - SlotExprPairVector aggs, + value::SlotMap<std::unique_ptr<EExpression>> aggs, value::SlotVector seekKeysSlots, bool optimizedClose, boost::optional<value::SlotId> collatorSlot, bool allowDiskUse, - SlotExprPairVector mergingExprs, - PlanNodeId planNodeId, - bool forceIncreasedSpilling = false); + PlanNodeId planNodeId); std::unique_ptr<PlanStage> clone() const final; @@ -124,147 +108,99 @@ private: using HashKeyAccessor = value::MaterializedRowKeyAccessor<TableType::iterator>; using HashAggAccessor = value::MaterializedRowValueAccessor<TableType::iterator>; - using SpilledRow = std::pair<value::MaterializedRow, value::MaterializedRow>; + void makeTemporaryRecordStore(); + + /** + * Spills a key and value pair to the '_recordStore' where the semantics are insert or update + * depending on the 'update' flag. When the 'update' flag is true this method already expects + * the 'key' to be inserted into the '_recordStore', otherwise the 'key' and 'val' pair are + * fresh. + * + * This method expects the key to be seralized into a KeyString::Value so that the key is + * memcmp-able and lookups can be done to update the 'val' in the '_recordStore'. Note that the + * 'typeBits' are needed to reconstruct the spilled 'key' when calling 'getNext' to deserialize + * the 'key' to a MaterializedRow. Since the '_recordStore' only stores the memcmp-able part of + * the KeyString we need to carry the 'typeBits' separately, and we do this by appending the + * 'typeBits' to the end of the serialized 'val' buffer and store them at the leaves of the + * backing B-tree of the '_recordStore'. used as the RecordId. + */ + void spillValueToDisk(const RecordId& key, + const value::MaterializedRow& val, + const KeyString::TypeBits& typeBits, + bool update); + void spillRowToDisk(const value::MaterializedRow& key, + const value::MaterializedRow& defaultVal); /** * We check amount of used memory every T processed incoming records, where T is calculated * based on the estimated used memory and its recent growth. When the memory limit is exceeded, - * 'checkMemoryUsageAndSpillIfNecessary()' will create '_recordStore' (if it hasn't already been - * created) and spill the contents of the hash table into this record store. + * 'checkMemoryUsageAndSpillIfNecessary()' will create '_recordStore' and might spill some of + * the already accumulated data into it. */ struct MemoryCheckData { - MemoryCheckData() { - reset(); - } - - void reset() { - memoryCheckFrequency = std::min(atMostCheckFrequency, atLeastMemoryCheckFrequency); - nextMemoryCheckpoint = 0; - memoryCheckpointCounter = 0; - lastEstimatedMemoryUsage = 0; - } - const double checkpointMargin = internalQuerySBEAggMemoryUseCheckMargin.load(); - const int64_t atMostCheckFrequency = internalQuerySBEAggMemoryCheckPerAdvanceAtMost.load(); - const int64_t atLeastMemoryCheckFrequency = + const long atMostCheckFrequency = internalQuerySBEAggMemoryCheckPerAdvanceAtMost.load(); + const long atLeastMemoryCheckFrequency = internalQuerySBEAggMemoryCheckPerAdvanceAtLeast.load(); // The check frequency upper bound, which start at 'atMost' and exponentially backs off // to 'atLeast' as more data is accumulated. If 'atLeast' is less than 'atMost', the memory // checks will be done every 'atLeast' incoming records. - int64_t memoryCheckFrequency = 1; + long memoryCheckFrequency = 1; // The number of incoming records to process before the next memory checkpoint. - int64_t nextMemoryCheckpoint = 0; + long nextMemoryCheckpoint = 0; // The counter of the incoming records between memory checkpoints. - int64_t memoryCheckpointCounter = 0; - - int64_t lastEstimatedMemoryUsage = 0; - }; + long memoryCheckpointCounter = 0; - /** - * Inserts a key and value pair to the '_recordStore'. They key is serialized to a - * 'KeyString::Value' which becomes the 'RecordId'. This makes the keys memcmp-able and ensures - * that the record store ends up sorted by the group-by keys. - * - * Note that the 'typeBits' are needed to reconstruct the spilled 'key' to a 'MaterializedRow', - * but are not necessary for comparison purposes. Therefore, we carry the type bits separately - * from the record id, instead appending them to the end of the serialized 'val' buffer. - */ - void spillRowToDisk(const value::MaterializedRow& key, const value::MaterializedRow& val); + long long lastEstimatedMemoryUsage = 0; + MemoryCheckData() { + memoryCheckFrequency = std::min(atMostCheckFrequency, atLeastMemoryCheckFrequency); + } + }; void checkMemoryUsageAndSpillIfNecessary(MemoryCheckData& mcd); - void spill(MemoryCheckData& mcd); - - /** - * Given a 'record' from the record store, decodes it into a pair of materialized rows (one for - * the group-by keys and another for the agg values). - * - * The given 'keyBuffer' is cleared, and then used to hold data (e.g. long strings and other - * values that can't be inlined) obtained by decoding the 'RecordId' keystring to a - * 'MaterializedRow'. The values in the resulting 'MaterializedRow' may be pointers into - * 'keyBuffer', so it is important that 'keyBuffer' outlive the row. - * - * This method is used when there is no collator. - */ - SpilledRow deserializeSpilledRecord(const Record& record, BufBuilder& keyBuffer); - - /** - * Given a 'record' from the record store and a 'collator', decodes it into a pair of - * materialized rows (one for the group-by key and another one for the agg value). - * Both the group-by key and the agg value are read from the data part of the record. - */ - SpilledRow deserializeSpilledRecord(const Record& record, const CollatorInterface& collator); - - PlanState getNextSpilled(); - - void makeTemporaryRecordStore(); const value::SlotVector _gbs; - const SlotExprPairVector _aggs; + const value::SlotMap<std::unique_ptr<EExpression>> _aggs; const boost::optional<value::SlotId> _collatorSlot; const bool _allowDiskUse; const value::SlotVector _seekKeysSlots; // When this operator does not expect to be reopened (almost always) then it can close the child // early. const bool _optimizedClose{true}; - - // Expressions used to merge partial aggregates that have been spilled to disk and their - // corresponding input slots. For example, imagine that this list contains a pair (s12, - // sum(s12)). This means that the partial aggregate values will be read into slot s12 after - // being recovered from the spill table and can be merged using the 'sum()' agg function. - // - // When disk use is allowed, this vector must have the same length as '_aggs'. - const SlotExprPairVector _mergingExprs; - - // When true, we spill frequently without reaching the memory limit. This allows us to exercise - // the spilling logic more often in test contexts. - const bool _forceIncreasedSpilling; - value::SlotAccessorMap _outAccessors; - - // Accessors used to obtain the values of the group by slots when reading the input from the - // child. std::vector<value::SlotAccessor*> _inKeyAccessors; - // This buffer stores values for '_outKeyRowRecordStore'; values in the '_outKeyRowRecordStore' - // can be pointers that point to data in this buffer. - BufBuilder _outKeyRowRSBuffer; - // Accessors for the key slots provided as output by this stage. The keys can either come from - // the hash table or recovered from a temporary record store. We use a 'SwitchAccessor' to - // switch between these two cases. + // Accessors for the key stored in '_ht', a SwitchAccessor is used so we can produce the key + // from either the '_ht' or the '_recordStore'. std::vector<std::unique_ptr<HashKeyAccessor>> _outHashKeyAccessors; - // Row of key values to output used when recovering spilled data from the record store. - value::MaterializedRow _outKeyRowRecordStore{0}; - std::vector<std::unique_ptr<value::MaterializedSingleRowAccessor>> _outRecordStoreKeyAccessors; std::vector<std::unique_ptr<value::SwitchAccessor>> _outKeyAccessors; - // Accessors for the output aggregate results. The aggregates can either come from the hash - // table or can be computed after merging partial aggregates spilled to a record store. We use a - // 'SwitchAccessor' to switch between these two cases. - std::vector<std::unique_ptr<HashAggAccessor>> _outHashAggAccessors; - // Row of agg values to output used when recovering spilled data from the record store. - value::MaterializedRow _outAggRowRecordStore{0}; + // Accessor for the agg state value stored in the '_recordStore' when data is spilled to disk. + value::MaterializedRow _aggKeyRecordStore{0}; + value::MaterializedRow _aggValueRecordStore{0}; + std::vector<std::unique_ptr<value::MaterializedSingleRowAccessor>> _outRecordStoreKeyAccessors; std::vector<std::unique_ptr<value::MaterializedSingleRowAccessor>> _outRecordStoreAggAccessors; - std::vector<std::unique_ptr<value::SwitchAccessor>> _outAggAccessors; + + // This buffer stores values for the spilled '_aggKeyRecordStore' that's loaded into memory from + // the '_recordStore'. Values in the '_aggKeyRecordStore' row are pointers that point to data in + // this buffer. + BufBuilder _aggKeyRSBuffer; std::vector<value::SlotAccessor*> _seekKeysAccessors; value::MaterializedRow _seekKeys; - // Bytecode which gets executed to aggregate incoming rows into the hash table. + // Accesors for the agg state in '_ht', a SwitchAccessor is used so we can produce the agg state + // from either the '_ht' or the '_recordStore' when draining the HashAgg stage. + std::vector<std::unique_ptr<value::SwitchAccessor>> _outAggAccessors; + std::vector<std::unique_ptr<HashAggAccessor>> _outHashAggAccessors; std::vector<std::unique_ptr<vm::CodeFragment>> _aggCodes; - // Bytecode for the merging expressions, executed if partial aggregates are spilled to a record - // store and need to be subsequently combined. - std::vector<std::unique_ptr<vm::CodeFragment>> _mergingExprCodes; // Only set if collator slot provided on construction. value::SlotAccessor* _collatorAccessor = nullptr; - // Function object which can be used to check whether two materialized rows of key values are - // equal. This comparison is collation-aware if the query has a non-simple collation. - value::MaterializedRowEq _keyEq; - boost::optional<TableType> _ht; TableType::iterator _htIt; @@ -276,31 +212,10 @@ private: // Memory tracking and spilling to disk. const long long _approxMemoryUseInBytesBeforeSpill = internalQuerySBEAggApproxMemoryUseInBytesBeforeSpill.load(); - - // A record store which is instantiated and written to in the case of spilling. - std::unique_ptr<SpillingStore> _recordStore; + std::unique_ptr<TemporaryRecordStore> _recordStore; + bool _drainingRecordStore{false}; std::unique_ptr<SeekableRecordCursor> _rsCursor; - // A monotically increasing counter used to ensure uniqueness of 'RecordId' values. When - // spilling, the key is encoding into the 'RecordId' of the '_recordStore'. Record ids must be - // unique by definition, but we might end up spilling multiple partial aggregates for the same - // key. We ensure uniqueness by appending a unique integer to the end of this key, which is - // simply ignored during deserialization. - int64_t _ridCounter = 0; - - // Partial aggregates that have been spilled are read into '_spilledAggRow' and read using - // '_spilledAggsAccessors' so that they can be merged to compute the final aggregate value. - value::MaterializedRow _spilledAggRow{0}; - std::vector<std::unique_ptr<value::MaterializedSingleRowAccessor>> _spilledAggsAccessors; - value::SlotAccessorMap _spilledAggsAccessorMap; - - // Buffer to hold data for the deserialized key values from '_stashedNextRow'. - BufBuilder _stashedKeyBuffer; - // Place to stash the next keys and values during the streaming phase. The record store cursor - // doesn't offer a "peek" API, so we need to hold onto the next row between getNext() calls when - // the key value advances. - SpilledRow _stashedNextRow; - HashAggStats _specificStats; // If provided, used during a trial run to accumulate certain execution stats. Once the trial diff --git a/src/mongo/db/exec/sbe/stages/hash_lookup.cpp b/src/mongo/db/exec/sbe/stages/hash_lookup.cpp index 02e95307c4b..0d976f1a875 100644 --- a/src/mongo/db/exec/sbe/stages/hash_lookup.cpp +++ b/src/mongo/db/exec/sbe/stages/hash_lookup.cpp @@ -187,22 +187,6 @@ value::SlotAccessor* HashLookupStage::getAccessor(CompileCtx& ctx, value::SlotId return outerChild()->getAccessor(ctx, slot); } } -void HashLookupStage::doSaveState(bool relinquishCursor) { - if (_recordStoreHt) { - _recordStoreHt->saveState(); - } - if (_recordStoreBuf) { - _recordStoreBuf->saveState(); - } -} -void HashLookupStage::doRestoreState(bool relinquishCursor) { - if (_recordStoreHt) { - _recordStoreHt->restoreState(); - } - if (_recordStoreBuf) { - _recordStoreBuf->restoreState(); - } -} void HashLookupStage::reset() { _ht = boost::none; @@ -275,7 +259,7 @@ void HashLookupStage::addHashTableEntry(value::SlotAccessor* keyAccessor, size_t auto val = std::vector<size_t>{valueIndex}; auto [tagKey, valKey] = keyAccessor->getViewOfValue(); - spillIndicesToRecordStore(_recordStoreHt.get(), tagKey, valKey, val); + spillIndicesToRecordStore(_recordStoreHt->rs(), tagKey, valKey, val); } } else { // The key is already present in '_ht' so the memory will only grow by one size_t. If we @@ -297,7 +281,7 @@ void HashLookupStage::addHashTableEntry(value::SlotAccessor* keyAccessor, size_t // Evict the hash table value. _computedTotalMemUsage -= htIt->second.size() * sizeof(size_t); htIt->second.push_back(valueIndex); - spillIndicesToRecordStore(_recordStoreHt.get(), tagKeyView, valKeyView, htIt->second); + spillIndicesToRecordStore(_recordStoreHt->rs(), tagKeyView, valKeyView, htIt->second); _ht->erase(htIt); } } @@ -313,15 +297,17 @@ void HashLookupStage::makeTemporaryRecordStore() { _opCtx->getServiceContext()->getStorageEngine()); assertIgnorePrepareConflictsBehavior(_opCtx); - _recordStoreBuf = std::make_unique<SpillingStore>(_opCtx, KeyFormat::Long); + _recordStoreBuf = _opCtx->getServiceContext()->getStorageEngine()->makeTemporaryRecordStore( + _opCtx, KeyFormat::Long); - _recordStoreHt = std::make_unique<SpillingStore>(_opCtx, KeyFormat::String); + _recordStoreHt = _opCtx->getServiceContext()->getStorageEngine()->makeTemporaryRecordStore( + _opCtx, KeyFormat::String); _specificStats.usedDisk = true; } void HashLookupStage::spillBufferedValueToDisk(OperationContext* opCtx, - SpillingStore* rs, + RecordStore* rs, size_t bufferIdx, const value::MaterializedRow& val) { auto rid = getValueRecordId(bufferIdx); @@ -329,7 +315,15 @@ void HashLookupStage::spillBufferedValueToDisk(OperationContext* opCtx, BufBuilder buf; val.serializeForSorter(buf); - rs->upsertToRecordStore(opCtx, rid, buf, false); + assertIgnorePrepareConflictsBehavior(opCtx); + WriteUnitOfWork wuow(opCtx); + + auto status = rs->insertRecord(opCtx, rid, buf.buf(), buf.len(), Timestamp{}); + wuow.commit(); + + tassert(6373906, + str::stream() << "Failed to write to disk because " << status.getStatus().reason(), + status.isOK()); _specificStats.spilledBuffRecords++; // Add size of record ID + size of buffer. @@ -340,14 +334,14 @@ void HashLookupStage::spillBufferedValueToDisk(OperationContext* opCtx, size_t HashLookupStage::bufferValueOrSpill(value::MaterializedRow& value) { size_t bufferIndex = _valueId; const long long newMemUsage = _computedTotalMemUsage + size_estimator::estimate(value); - if (!hasSpilledBufToDisk() && newMemUsage <= _memoryUseInBytesBeforeSpill) { + if (newMemUsage <= _memoryUseInBytesBeforeSpill) { _buffer.emplace_back(std::move(value)); _computedTotalMemUsage = newMemUsage; } else { if (!hasSpilledBufToDisk()) { makeTemporaryRecordStore(); } - spillBufferedValueToDisk(_opCtx, _recordStoreBuf.get(), bufferIndex, value); + spillBufferedValueToDisk(_opCtx, _recordStoreBuf->rs(), bufferIndex, value); } _valueId++; return bufferIndex; @@ -433,7 +427,7 @@ void HashLookupStage::accumulateFromValueIndices(const C& bufferIndices) { // We must shift the '_bufferIt' index by one when using it as a RecordId because a // RecordId of 0 is invalid. auto rid = getValueRecordId(_bufferIt); - auto rsValue = _recordStoreBuf->readFromRecordStore(_opCtx, rid); + auto rsValue = readFromRecordStore(_opCtx, _recordStoreBuf->rs(), rid); if (!rsValue) { tasserted(6373900, "bufferIdx not found in record store"); } @@ -449,7 +443,7 @@ void HashLookupStage::accumulateFromValueIndices(const C& bufferIndices) { } } -void HashLookupStage::writeIndicesToRecordStore(SpillingStore* rs, +void HashLookupStage::writeIndicesToRecordStore(RecordStore* rs, value::TypeTags tagKey, value::Value valKey, const std::vector<size_t>& value, @@ -464,7 +458,7 @@ void HashLookupStage::writeIndicesToRecordStore(SpillingStore* rs, key.reset(0, false, tagKey, valKey); auto [rid, typeBits] = serializeKeyForRecordStore(key); - rs->upsertToRecordStore(_opCtx, rid, buf, typeBits, update); + upsertToRecordStore(_opCtx, rs, rid, buf, typeBits, update); if (!update) { _specificStats.spilledHtRecords++; // Add the size of key (which comprises of the memory usage for the key + its type bits), @@ -477,7 +471,7 @@ void HashLookupStage::writeIndicesToRecordStore(SpillingStore* rs, } boost::optional<std::vector<size_t>> HashLookupStage::readIndicesFromRecordStore( - SpillingStore* rs, value::TypeTags tagKey, value::Value valKey) { + RecordStore* rs, value::TypeTags tagKey, value::Value valKey) { _probeKey.reset(0, false, tagKey, valKey); auto [rid, _] = serializeKeyForRecordStore(_probeKey); @@ -496,7 +490,7 @@ boost::optional<std::vector<size_t>> HashLookupStage::readIndicesFromRecordStore return boost::none; } -void HashLookupStage::spillIndicesToRecordStore(SpillingStore* rs, +void HashLookupStage::spillIndicesToRecordStore(RecordStore* rs, value::TypeTags tagKey, value::Value valKey, const std::vector<size_t>& value) { @@ -551,7 +545,7 @@ PlanState HashLookupStage::getNext() { normalizeStringIfCollator(tagElemView, valElemView); auto indicesFromRS = readIndicesFromRecordStore( - _recordStoreHt.get(), tagElemCollView, valElemCollView); + _recordStoreHt->rs(), tagElemCollView, valElemCollView); if (indicesFromRS) { indices.insert(indicesFromRS->begin(), indicesFromRS->end()); } @@ -573,7 +567,7 @@ PlanState HashLookupStage::getNext() { normalizeStringIfCollator(tagKeyView, valKeyView); auto indicesFromRS = readIndicesFromRecordStore( - _recordStoreHt.get(), tagKeyCollView, valKeyCollView); + _recordStoreHt->rs(), tagKeyCollView, valKeyCollView); if (indicesFromRS) { accumulateFromValueIndices(*indicesFromRS); } diff --git a/src/mongo/db/exec/sbe/stages/hash_lookup.h b/src/mongo/db/exec/sbe/stages/hash_lookup.h index b312e0a68f4..2e3f0b34816 100644 --- a/src/mongo/db/exec/sbe/stages/hash_lookup.h +++ b/src/mongo/db/exec/sbe/stages/hash_lookup.h @@ -33,7 +33,6 @@ #include "mongo/db/exec/sbe/expressions/expression.h" #include "mongo/db/exec/sbe/stages/stages.h" -#include "mongo/db/exec/sbe/util/spilling.h" #include "mongo/db/exec/sbe/vm/vm.h" #include "mongo/db/query/query_knobs_gen.h" @@ -102,10 +101,6 @@ public: std::vector<DebugPrinter::Block> debugPrint() const final; size_t estimateCompileTimeSize() const final; -protected: - void doSaveState(bool relinquishCursor) override; - void doRestoreState(bool relinquishCursor) override; - private: using HashTableType = std::unordered_map<value::MaterializedRow, // NOLINT std::vector<size_t>, @@ -124,23 +119,23 @@ private: // Spilling helpers. void addHashTableEntry(value::SlotAccessor* keyAccessor, size_t valueIndex); void spillBufferedValueToDisk(OperationContext* opCtx, - SpillingStore* rs, + RecordStore* rs, size_t bufferIdx, const value::MaterializedRow&); size_t bufferValueOrSpill(value::MaterializedRow& value); void setInnerProjectSwitchAccessor(int idx); - boost::optional<std::vector<size_t>> readIndicesFromRecordStore(SpillingStore* rs, + boost::optional<std::vector<size_t>> readIndicesFromRecordStore(RecordStore* rs, value::TypeTags tagKey, value::Value valKey); - void writeIndicesToRecordStore(SpillingStore* rs, + void writeIndicesToRecordStore(RecordStore* rs, value::TypeTags tagKey, value::Value valKey, const std::vector<size_t>& value, bool update); - void spillIndicesToRecordStore(SpillingStore* rs, + void spillIndicesToRecordStore(RecordStore* rs, value::TypeTags tagKey, value::Value valKey, const std::vector<size_t>& value); @@ -234,8 +229,8 @@ private: // rows in '_buffer'. long long _computedTotalMemUsage = 0; - std::unique_ptr<SpillingStore> _recordStoreHt; - std::unique_ptr<SpillingStore> _recordStoreBuf; + std::unique_ptr<TemporaryRecordStore> _recordStoreHt; + std::unique_ptr<TemporaryRecordStore> _recordStoreBuf; HashLookupStats _specificStats; }; diff --git a/src/mongo/db/exec/sbe/stages/ix_scan.cpp b/src/mongo/db/exec/sbe/stages/ix_scan.cpp index fe88d9c9095..bfad6d9a2ae 100644 --- a/src/mongo/db/exec/sbe/stages/ix_scan.cpp +++ b/src/mongo/db/exec/sbe/stages/ix_scan.cpp @@ -45,7 +45,6 @@ IndexScanStage::IndexScanStage(UUID collUuid, boost::optional<value::SlotId> recordSlot, boost::optional<value::SlotId> recordIdSlot, boost::optional<value::SlotId> snapshotIdSlot, - boost::optional<value::SlotId> indexIdSlot, IndexKeysInclusionSet indexKeysToInclude, value::SlotVector vars, boost::optional<value::SlotId> seekKeySlotLow, @@ -59,7 +58,6 @@ IndexScanStage::IndexScanStage(UUID collUuid, _recordSlot(recordSlot), _recordIdSlot(recordIdSlot), _snapshotIdSlot(snapshotIdSlot), - _indexIdSlot(indexIdSlot), _indexKeysToInclude(indexKeysToInclude), _vars(std::move(vars)), _seekKeySlotLow(seekKeySlotLow), @@ -78,7 +76,6 @@ std::unique_ptr<PlanStage> IndexScanStage::clone() const { _recordSlot, _recordIdSlot, _snapshotIdSlot, - _indexIdSlot, _indexKeysToInclude, _vars, _seekKeySlotLow, @@ -131,17 +128,10 @@ void IndexScanStage::prepare(CompileCtx& ctx) { static_cast<bool>(entry)); _ordering = entry->ordering(); - auto [indexIdTag, indexIdVal] = value::makeNewString(StringData(_indexName)); - _indexIdAccessor.reset(indexIdTag, indexIdVal); - - if (_indexIdSlot) { - _indexIdViewAccessor.reset(indexIdTag, indexIdVal); - } else { - _indexIdViewAccessor.reset(); - } - if (_snapshotIdAccessor) { - _latestSnapshotId = _opCtx->recoveryUnit()->getSnapshotId().toNumber(); + _snapshotIdAccessor->reset( + value::TypeTags::NumberInt64, + value::bitcastFrom<uint64_t>(_opCtx->recoveryUnit()->getSnapshotId().toNumber())); } } @@ -158,10 +148,6 @@ value::SlotAccessor* IndexScanStage::getAccessor(CompileCtx& ctx, value::SlotId return _snapshotIdAccessor.get(); } - if (_indexIdSlot && *_indexIdSlot == slot) { - return &_indexIdViewAccessor; - } - if (auto it = _accessorMap.find(slot); it != _accessorMap.end()) { return it->second; } @@ -233,7 +219,9 @@ void IndexScanStage::doRestoreState(bool relinquishCursor) { // Yield is the only time during plan execution that the snapshotId can change. As such, we // update it accordingly as part of yield recovery. if (_snapshotIdAccessor) { - _latestSnapshotId = _opCtx->recoveryUnit()->getSnapshotId().toNumber(); + _snapshotIdAccessor->reset( + value::TypeTags::NumberInt64, + value::bitcastFrom<uint64_t>(_opCtx->recoveryUnit()->getSnapshotId().toNumber())); } } @@ -397,12 +385,6 @@ PlanState IndexScanStage::getNext() { false, value::TypeTags::RecordId, value::bitcastFrom<RecordId*>(&_nextRecord->loc)); } - if (_snapshotIdAccessor) { - // Copy the latest snapshot ID into the 'snapshotId' slot. - _snapshotIdAccessor->reset(value::TypeTags::NumberInt64, - value::bitcastFrom<uint64_t>(_latestSnapshotId)); - } - if (_accessors.size()) { _valuesBuffer.reset(); readKeyStringValueIntoAccessors( @@ -441,9 +423,6 @@ std::unique_ptr<PlanStageStats> IndexScanStage::getStats(bool includeDebugInfo) if (_snapshotIdSlot) { bob.appendNumber("snapshotIdSlot", static_cast<long long>(*_snapshotIdSlot)); } - if (_indexIdSlot) { - bob.appendNumber("indexIdSlot", static_cast<long long>(*_indexIdSlot)); - } if (_seekKeySlotLow) { bob.appendNumber("seekKeySlotLow", static_cast<long long>(*_seekKeySlotLow)); } @@ -492,12 +471,6 @@ std::vector<DebugPrinter::Block> IndexScanStage::debugPrint() const { DebugPrinter::addIdentifier(ret, DebugPrinter::kNoneKeyword); } - if (_indexIdSlot) { - DebugPrinter::addIdentifier(ret, _indexIdSlot.value()); - } else { - DebugPrinter::addIdentifier(ret, DebugPrinter::kNoneKeyword); - } - ret.emplace_back(DebugPrinter::Block("[`")); size_t varIndex = 0; for (size_t keyIndex = 0; keyIndex < _indexKeysToInclude.size(); ++keyIndex) { diff --git a/src/mongo/db/exec/sbe/stages/ix_scan.h b/src/mongo/db/exec/sbe/stages/ix_scan.h index 33fcd352d0c..ce00ef17128 100644 --- a/src/mongo/db/exec/sbe/stages/ix_scan.h +++ b/src/mongo/db/exec/sbe/stages/ix_scan.h @@ -51,8 +51,7 @@ namespace mongo::sbe { * The "output" slots are * - 'recordSlot': the "KeyString" representing the index entry, * - 'recordIdSlot': a reference that can be used to fetch the entire document, - * - 'snapshotIdSlot': the storage snapshot that this index scan is reading from, - * - 'indexIdSlot': the name of the index being read from, and + * - 'snapshotIdSlot': the storage snapshot that this index scan is reading from, and * - 'vars': one slot for each value in the index key that should be "projected" out of the entry. * * The 'indexKeysToInclude' bitset determines which values are included in the projection based @@ -64,11 +63,10 @@ namespace mongo::sbe { * * Debug string representation: * - * ixscan recordSlot? recordIdSlot? snapshotIdSlot? indexIdSlot? - * [slot_1 = fieldNo_1, ..., slot2 = fieldNo_n] + * ixscan recordSlot? recordIdSlot? snapshotIdSlot? [slot_1 = fieldNo_1, ..., slot2 = fieldNo_n] * collectionUuid indexName forward * - * ixseek lowKey highKey recordSlot? recordIdSlot? snapshotIdSlot? indexIdSlot? + * ixseek lowKey highKey recordSlot? recordIdSlot? snapshotIdSlot? * [slot_1 = fieldNo_1, ..., slot2 = fieldNo_n] * collectionUuid indexName forward */ @@ -80,7 +78,6 @@ public: boost::optional<value::SlotId> recordSlot, boost::optional<value::SlotId> recordIdSlot, boost::optional<value::SlotId> snapshotIdSlot, - boost::optional<value::SlotId> indexIdSlot, IndexKeysInclusionSet indexKeysToInclude, value::SlotVector vars, boost::optional<value::SlotId> seekKeySlotLow, @@ -128,7 +125,6 @@ private: const boost::optional<value::SlotId> _recordSlot; const boost::optional<value::SlotId> _recordIdSlot; const boost::optional<value::SlotId> _snapshotIdSlot; - const boost::optional<value::SlotId> _indexIdSlot; const IndexKeysInclusionSet _indexKeysToInclude; const value::SlotVector _vars; const boost::optional<value::SlotId> _seekKeySlotLow; @@ -145,14 +141,6 @@ private: std::unique_ptr<value::OwnedValueAccessor> _recordIdAccessor; std::unique_ptr<value::OwnedValueAccessor> _snapshotIdAccessor; - value::OwnedValueAccessor _indexIdAccessor; - value::ViewOfValueAccessor _indexIdViewAccessor; - - // This field holds the latest snapshot ID that we've received from _opCtx->recoveryUnit(). - // This field gets initialized by prepare(), and it gets updated each time doRestoreState() is - // called. - uint64_t _latestSnapshotId{0}; - // One accessor and slot for each key component that this stage will bind from an index entry's // KeyString. The accessors are in the same order as the key components they bind to. std::vector<value::OwnedValueAccessor> _accessors; diff --git a/src/mongo/db/exec/sbe/stages/plan_stats.h b/src/mongo/db/exec/sbe/stages/plan_stats.h index f487c7a45d2..263a4f86660 100644 --- a/src/mongo/db/exec/sbe/stages/plan_stats.h +++ b/src/mongo/db/exec/sbe/stages/plan_stats.h @@ -278,13 +278,8 @@ struct HashAggStats : public SpecificStats { } bool usedDisk{false}; - // The number of times that the entire hash table was spilled. - long long numSpills{0}; - // The number of individual records spilled to disk. long long spilledRecords{0}; - // An estimate, in bytes, of the size of the final spill table after all spill events have taken - // place. - long long spilledDataStorageSize{0}; + long long lastSpilledRecordSize{0}; }; struct HashLookupStats : public SpecificStats { diff --git a/src/mongo/db/exec/sbe/stages/scan.cpp b/src/mongo/db/exec/sbe/stages/scan.cpp index 3d601d8779e..678d3f84ef9 100644 --- a/src/mongo/db/exec/sbe/stages/scan.cpp +++ b/src/mongo/db/exec/sbe/stages/scan.cpp @@ -209,7 +209,6 @@ void ScanStage::doSaveState(bool relinquishCursor) { cursor->setSaveStorageCursorOnDetachFromOperationContext(!relinquishCursor); } - _indexCatalogEntryMap.clear(); _coll.reset(); } @@ -392,14 +391,9 @@ PlanState ScanStage::getNext() { } // Return EOF if the index key is found to be inconsistent. - if (_scanCallbacks.indexKeyConsistencyCheckCallback && - !_scanCallbacks.indexKeyConsistencyCheckCallback(_opCtx, - _indexCatalogEntryMap, - _snapshotIdAccessor, - _indexIdAccessor, - _indexKeyAccessor, - _coll, - *nextRecord)) { + if (_scanCallbacks.indexKeyConsistencyCheckCallBack && + !_scanCallbacks.indexKeyConsistencyCheckCallBack( + _opCtx, _snapshotIdAccessor, _indexIdAccessor, _indexKeyAccessor, _coll, *nextRecord)) { return trackPlanState(PlanState::IS_EOF); } @@ -463,7 +457,6 @@ void ScanStage::close() { auto optTimer(getOptTimer(_opCtx)); trackClose(); - _indexCatalogEntryMap.clear(); _cursor.reset(); _randomCursor.reset(); _coll.reset(); @@ -749,7 +742,6 @@ void ParallelScanStage::doSaveState(bool relinquishCursor) { _cursor->save(); } - _indexCatalogEntryMap.clear(); _coll.reset(); } @@ -907,9 +899,8 @@ PlanState ParallelScanStage::getNext() { } // Return EOF if the index key is found to be inconsistent. - if (_scanCallbacks.indexKeyConsistencyCheckCallback && - !_scanCallbacks.indexKeyConsistencyCheckCallback(_opCtx, - _indexCatalogEntryMap, + if (_scanCallbacks.indexKeyConsistencyCheckCallBack && + !_scanCallbacks.indexKeyConsistencyCheckCallBack(_opCtx, _snapshotIdAccessor, _indexIdAccessor, _indexKeyAccessor, @@ -965,7 +956,6 @@ void ParallelScanStage::close() { auto optTimer(getOptTimer(_opCtx)); trackClose(); - _indexCatalogEntryMap.clear(); _cursor.reset(); _coll.reset(); _open = false; diff --git a/src/mongo/db/exec/sbe/stages/scan.h b/src/mongo/db/exec/sbe/stages/scan.h index 6f4980f52e1..37462ac5e14 100644 --- a/src/mongo/db/exec/sbe/stages/scan.h +++ b/src/mongo/db/exec/sbe/stages/scan.h @@ -45,11 +45,11 @@ struct ScanCallbacks { IndexKeyConsistencyCheckCallback indexKeyConsistencyCheck = {}, ScanOpenCallback scanOpen = {}) : indexKeyCorruptionCheckCallback(std::move(indexKeyCorruptionCheck)), - indexKeyConsistencyCheckCallback(std::move(indexKeyConsistencyCheck)), + indexKeyConsistencyCheckCallBack(std::move(indexKeyConsistencyCheck)), scanOpenCallback(std::move(scanOpen)) {} IndexKeyCorruptionCheckCallback indexKeyCorruptionCheckCallback; - IndexKeyConsistencyCheckCallback indexKeyConsistencyCheckCallback; + IndexKeyConsistencyCheckCallback indexKeyConsistencyCheckCallBack; ScanOpenCallback scanOpenCallback; }; @@ -83,12 +83,12 @@ struct ScanCallbacks { * * Debug string representations: * - * scan recordSlot? recordIdSlot? snapshotIdSlot? indexIdSlot? indexKeySlot? - * indexKeyPatternSlot? [slot1 = fieldName1, ... slot_n = fieldName_n] collectionUuid + * scan recordSlot|none recordIdSlot|none snapshotIdSlot|none indexIdSlot|none indexKeySlot|none + * indexKeyPatternSlot|none [slot1 = fieldName1, ... slot_n = fieldName_n] collectionUuid * forward needOplogSlotForTs * - * seek seekKeySlot recordSlot? recordIdSlot? snapshotIdSlot? indexIdSlot? indexKeySlot? - * indexKeyPatternSlot? [slot1 = fieldName1, ... slot_n = fieldName_n] + * seek seekKeySlot recordSlot|none recordIdSlot|none snapshotIdSlot|none indexIdSlot|none + * indexKeySlot|none indexKeyPatternSlot|none [slot1 = fieldName1, ... slot_n = fieldName_n] * collectionUuid forward needOplogSlotForTs */ class ScanStage final : public PlanStage { @@ -197,8 +197,6 @@ private: // collection is still valid. Only relevant to capped collections. bool _needsToCheckCappedPositionLost = false; - StringMap<const IndexCatalogEntry*> _indexCatalogEntryMap; - #if defined(MONGO_CONFIG_DEBUG_BUILD) // Debug-only buffer used to track the last thing returned from the stage. Between // saves/restores this is used to check that the storage cursor has not changed position. @@ -313,8 +311,6 @@ private: std::unique_ptr<SeekableRecordCursor> _cursor; - StringMap<const IndexCatalogEntry*> _indexCatalogEntryMap; - #if defined(MONGO_CONFIG_DEBUG_BUILD) // Debug-only buffer used to track the last thing returned from the stage. Between // saves/restores this is used to check that the storage cursor has not changed position. diff --git a/src/mongo/db/exec/sbe/stages/sort.cpp b/src/mongo/db/exec/sbe/stages/sort.cpp index eebdc0c2443..5acf73afe8d 100644 --- a/src/mongo/db/exec/sbe/stages/sort.cpp +++ b/src/mongo/db/exec/sbe/stages/sort.cpp @@ -213,11 +213,11 @@ void SortStage::open(bool reOpen) { _specificStats.totalDataSizeBytes += _sorter->totalDataSizeSorted(); _mergeIt.reset(_sorter->done()); - _specificStats.spills += _sorter->stats().spilledRanges(); + _specificStats.spills += _sorter->numSpills(); _specificStats.keysSorted += _sorter->numSorted(); auto& metricsCollector = ResourceConsumption::MetricsCollector::get(_opCtx); metricsCollector.incrementKeysSorted(_sorter->numSorted()); - metricsCollector.incrementSorterSpills(_sorter->stats().spilledRanges()); + metricsCollector.incrementSorterSpills(_sorter->numSpills()); _children[0]->close(); } diff --git a/src/mongo/db/exec/sbe/stages/union.cpp b/src/mongo/db/exec/sbe/stages/union.cpp index 3ddadb8c912..a661e6c579f 100644 --- a/src/mongo/db/exec/sbe/stages/union.cpp +++ b/src/mongo/db/exec/sbe/stages/union.cpp @@ -62,30 +62,28 @@ std::unique_ptr<PlanStage> UnionStage::clone() const { } void UnionStage::prepare(CompileCtx& ctx) { + value::SlotSet dupCheck; + for (size_t childNum = 0; childNum < _children.size(); childNum++) { _children[childNum]->prepare(ctx); } - // All of the slots listed in '_outputVals' must be unique. - value::SlotSet dupCheck; - for (auto slot : _outputVals) { - auto [it, inserted] = dupCheck.insert(slot); - uassert(4822807, str::stream() << "duplicate field: " << slot, inserted); - } - for (size_t idx = 0; idx < _outputVals.size(); ++idx) { std::vector<value::SlotAccessor*> accessors; accessors.reserve(_children.size()); for (size_t childNum = 0; childNum < _children.size(); childNum++) { - // Slots listed in '_inputVals' may not appear in '_outputVals'. auto slot = _inputVals[childNum][idx]; - bool slotFound = dupCheck.count(slot); - uassert(4822806, str::stream() << "duplicate field: " << slot, !slotFound); + auto [it, inserted] = dupCheck.insert(slot); + uassert(4822806, str::stream() << "duplicate field: " << slot, inserted); accessors.emplace_back(_children[childNum]->getAccessor(ctx, slot)); } + auto slot = _outputVals[idx]; + auto [it, inserted] = dupCheck.insert(slot); + uassert(4822807, str::stream() << "duplicate field: " << slot, inserted); + _outValueAccessors.emplace_back(value::SwitchAccessor{std::move(accessors)}); } } diff --git a/src/mongo/db/exec/sbe/util/spilling.cpp b/src/mongo/db/exec/sbe/util/spilling.cpp index 7675fad6846..c54f3bfe956 100644 --- a/src/mongo/db/exec/sbe/util/spilling.cpp +++ b/src/mongo/db/exec/sbe/util/spilling.cpp @@ -29,18 +29,6 @@ #include "mongo/db/exec/sbe/util/spilling.h" -#include "mongo/base/status.h" -#include "mongo/base/status_with.h" -#include "mongo/base/string_data.h" -#include "mongo/bson/timestamp.h" -#include "mongo/db/query/query_knobs_gen.h" -#include "mongo/db/storage/record_data.h" -#include "mongo/db/storage/recovery_unit.h" -#include "mongo/db/storage/write_unit_of_work.h" -#include "mongo/util/assert_util.h" -#include "mongo/util/bufreader.h" -#include "mongo/util/str.h" - namespace mongo { namespace sbe { @@ -69,136 +57,56 @@ KeyString::Value decodeKeyString(const RecordId& rid, KeyString::TypeBits typeBi return kb.getValueCopy(); } -SpillingStore::SpillingStore(OperationContext* opCtx, KeyFormat format) { - _recordStore = - opCtx->getServiceContext()->getStorageEngine()->makeTemporaryRecordStore(opCtx, format); - - _spillingUnit = std::unique_ptr<RecoveryUnit>( - opCtx->getServiceContext()->getStorageEngine()->newRecoveryUnit()); - _spillingUnit->setCacheMaxWaitTimeout(Milliseconds(internalQuerySpillingMaxWaitTimeout.load())); - _spillingState = WriteUnitOfWork::RecoveryUnitState::kNotInUnitOfWork; -} - -SpillingStore::~SpillingStore() {} - -int SpillingStore::upsertToRecordStore(OperationContext* opCtx, - const RecordId& recordKey, - const value::MaterializedRow& key, - const value::MaterializedRow& val, - bool update) { - BufBuilder buf; - key.serializeForSorter(buf); - val.serializeForSorter(buf); - return upsertToRecordStore(opCtx, recordKey, buf, update); +boost::optional<value::MaterializedRow> readFromRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& rid) { + RecordData record; + if (rs->findRecord(opCtx, rid, &record)) { + auto valueReader = BufReader(record.data(), record.size()); + return value::MaterializedRow::deserializeForSorter(valueReader, {}); + } + return boost::none; } -int SpillingStore::upsertToRecordStore( - OperationContext* opCtx, - const RecordId& key, - const value::MaterializedRow& val, - const KeyString::TypeBits& typeBits, // recover type of value. - bool update) { +int upsertToRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& key, + const value::MaterializedRow& val, + const KeyString::TypeBits& typeBits, // recover type of value. + bool update) { BufBuilder bufValue; val.serializeForSorter(bufValue); - // Append the 'typeBits' to the end of the val's buffer so the 'key' can be reconstructed when - // draining HashAgg. - bufValue.appendBuf(typeBits.getBuffer(), typeBits.getSize()); - - return upsertToRecordStore(opCtx, key, bufValue, update); + return upsertToRecordStore(opCtx, rs, key, bufValue, typeBits, update); } -int SpillingStore::upsertToRecordStore( - OperationContext* opCtx, - const RecordId& key, - BufBuilder& buf, - const KeyString::TypeBits& typeBits, // recover type of value. - bool update) { +int upsertToRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& key, + BufBuilder& buf, + const KeyString::TypeBits& typeBits, // recover type of value. + bool update) { + // Append the 'typeBits' to the end of the val's buffer so the 'key' can be reconstructed when // draining HashAgg. buf.appendBuf(typeBits.getBuffer(), typeBits.getSize()); - return upsertToRecordStore(opCtx, key, buf, update); -} - -int SpillingStore::upsertToRecordStore(OperationContext* opCtx, - const RecordId& key, - BufBuilder& buf, - bool update) { assertIgnorePrepareConflictsBehavior(opCtx); - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); WriteUnitOfWork wuow(opCtx); auto result = mongo::Status::OK(); if (update) { - result = rs()->updateRecord(opCtx, key, buf.buf(), buf.len()); + result = rs->updateRecord(opCtx, key, buf.buf(), buf.len()); } else { - auto status = rs()->insertRecord(opCtx, key, buf.buf(), buf.len(), Timestamp{}); + auto status = rs->insertRecord(opCtx, key, buf.buf(), buf.len(), Timestamp{}); result = status.getStatus(); } wuow.commit(); - if (!result.isOK()) { tasserted(5843600, str::stream() << "Failed to write to disk because " << result.reason()); return 0; } return buf.len(); } - -Status SpillingStore::insertRecords(OperationContext* opCtx, - std::vector<Record>* inOutRecords, - const std::vector<Timestamp>& timestamps) { - assertIgnorePrepareConflictsBehavior(opCtx); - - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - WriteUnitOfWork wuow(opCtx); - auto status = rs()->insertRecords(opCtx, inOutRecords, timestamps); - wuow.commit(); - - return status; -} - -boost::optional<value::MaterializedRow> SpillingStore::readFromRecordStore(OperationContext* opCtx, - const RecordId& rid) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - - RecordData record; - if (rs()->findRecord(opCtx, rid, &record)) { - auto valueReader = BufReader(record.data(), record.size()); - return value::MaterializedRow::deserializeForSorter(valueReader, {}); - } - return boost::none; -} - -bool SpillingStore::findRecord(OperationContext* opCtx, const RecordId& loc, RecordData* out) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - - return rs()->findRecord(opCtx, loc, out); -} - -void SpillingStore::switchToSpilling(OperationContext* opCtx) { - invariant(!_originalUnit); - _originalUnit = opCtx->releaseRecoveryUnit(); - _originalState = opCtx->setRecoveryUnit(std::move(_spillingUnit), _spillingState); -} -void SpillingStore::switchToOriginal(OperationContext* opCtx) { - invariant(!_spillingUnit); - _spillingUnit = opCtx->releaseRecoveryUnit(); - _spillingState = opCtx->setRecoveryUnit(std::move(_originalUnit), _originalState); - invariant(!(_spillingUnit->getState() == RecoveryUnit::State::kInactiveInUnitOfWork || - _spillingUnit->getState() == RecoveryUnit::State::kActive)); -} - -void SpillingStore::saveState() { - _spillingUnit->abandonSnapshot(); -} -void SpillingStore::restoreState() { - // We do not have to do anything. -} - } // namespace sbe } // namespace mongo diff --git a/src/mongo/db/exec/sbe/util/spilling.h b/src/mongo/db/exec/sbe/util/spilling.h index 205d6f1a031..95f73e2b02e 100644 --- a/src/mongo/db/exec/sbe/util/spilling.h +++ b/src/mongo/db/exec/sbe/util/spilling.h @@ -29,14 +29,9 @@ #pragma once -#include <boost/optional/optional.hpp> -#include <utility> +#include "mongo/platform/basic.h" -#include "mongo/bson/util/builder.h" #include "mongo/db/exec/sbe/values/slot.h" -#include "mongo/db/operation_context.h" -#include "mongo/db/record_id.h" -#include "mongo/db/storage/record_store.h" #include "mongo/db/storage/temporary_record_store.h" namespace mongo { @@ -55,104 +50,27 @@ std::pair<RecordId, KeyString::TypeBits> encodeKeyString(KeyString::Builder&, // Reconstructs the KeyString carried in RecordId using 'typeBits'. KeyString::Value decodeKeyString(const RecordId& rid, KeyString::TypeBits typeBits); -/** - * SpillingStore is a wrapper around a temporary record store than maintains its own transaction as - * we do not want to intermingle operations running in the main query with spill reads and writes. - */ -class SpillingStore { -public: - SpillingStore(OperationContext* opCtx, KeyFormat format = KeyFormat::String); - ~SpillingStore(); - - /** - * When a collator is provided, the key is encoded using the collator before being converted to - * a record id. In this case, it is not possible to recover the key from the record id, thus we - * need to store the original value of the key as well. - */ - int upsertToRecordStore(OperationContext* opCtx, - const RecordId& recordKey, - const value::MaterializedRow& key, - const value::MaterializedRow& val, - bool update); - /** - * Inserts or updates a key/value into 'rs'. The 'update' flag controls whether or not an update - * will be performed. If a key/value pair is inserted into the 'rs' that already exists and - * 'update' is false, this function will tassert. - * - * Returns the size of the new record in bytes, including the record id and value portions. - */ - int upsertToRecordStore(OperationContext* opCtx, - const RecordId& key, - const value::MaterializedRow& val, - const KeyString::TypeBits& typeBits, - bool update); - int upsertToRecordStore(OperationContext* opCtx, - const RecordId& key, - BufBuilder& buf, - const KeyString::TypeBits& typeBits, // recover type of value. - bool update); - int upsertToRecordStore(OperationContext* opCtx, - const RecordId& key, - BufBuilder& buf, - bool update); - - - Status insertRecords(OperationContext* opCtx, - std::vector<Record>* inOutRecords, - const std::vector<Timestamp>& timestamps); - - // Reads a materialized row from the record store. - boost::optional<value::MaterializedRow> readFromRecordStore(OperationContext* opCtx, - const RecordId& rid); - - bool findRecord(OperationContext* opCtx, const RecordId& loc, RecordData* out); - - auto rs() { - return _recordStore->rs(); - } - - auto getCursor(OperationContext* opCtx) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - return rs()->getCursor(opCtx); - } - - void resetCursor(OperationContext* opCtx, std::unique_ptr<SeekableRecordCursor>& cursor) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - cursor.reset(); - } +// Reads a materialized row from the record store. +boost::optional<value::MaterializedRow> readFromRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& rid); - auto saveCursor(OperationContext* opCtx, std::unique_ptr<SeekableRecordCursor>& cursor) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - - return cursor->save(); - } - - auto restoreCursor(OperationContext* opCtx, std::unique_ptr<SeekableRecordCursor>& cursor) { - switchToSpilling(opCtx); - ON_BLOCK_EXIT([&] { switchToOriginal(opCtx); }); - - return cursor->restore(); - } - - void saveState(); - void restoreState(); - -private: - void switchToSpilling(OperationContext* opCtx); - void switchToOriginal(OperationContext* opCtx); - - std::unique_ptr<TemporaryRecordStore> _recordStore; - - std::unique_ptr<RecoveryUnit> _originalUnit; - WriteUnitOfWork::RecoveryUnitState _originalState; - - std::unique_ptr<RecoveryUnit> _spillingUnit; - WriteUnitOfWork::RecoveryUnitState _spillingState; - - size_t _counter{0}; -}; +/** Inserts or updates a key/value into 'rs'. The 'update' flag controls whether or not an update + * will be performed. If a key/value pair is inserted into the 'rs' that already exists and + * 'update' is false, this function will tassert. + */ +int upsertToRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& key, + const value::MaterializedRow& val, + const KeyString::TypeBits& typeBits, + bool update); + +int upsertToRecordStore(OperationContext* opCtx, + RecordStore* rs, + const RecordId& key, + BufBuilder& buf, + const KeyString::TypeBits& typeBits, // recover type of value. + bool update); } // namespace sbe } // namespace mongo diff --git a/src/mongo/db/exec/sbe/values/slot.cpp b/src/mongo/db/exec/sbe/values/slot.cpp index 93605a9abfa..45cbc977980 100644 --- a/src/mongo/db/exec/sbe/values/slot.cpp +++ b/src/mongo/db/exec/sbe/values/slot.cpp @@ -42,9 +42,7 @@ #include "mongo/util/bufreader.h" namespace mongo::sbe::value { - -static std::pair<TypeTags, Value> deserializeValue(BufReader& buf, - const CollatorInterface* collator) { +static std::pair<TypeTags, Value> deserializeValue(BufReader& buf) { auto tag = static_cast<TypeTags>(buf.read<uint8_t>()); Value val; @@ -109,7 +107,7 @@ static std::pair<TypeTags, Value> deserializeValue(BufReader& buf, if (cnt) { arr->reserve(cnt); for (size_t idx = 0; idx < cnt; ++idx) { - auto [tag, val] = deserializeValue(buf, collator); + auto [tag, val] = deserializeValue(buf); arr->push_back(tag, val); } } @@ -118,16 +116,13 @@ static std::pair<TypeTags, Value> deserializeValue(BufReader& buf, break; } case TypeTags::ArraySet: { - // The first byte is a flag to tell us whether the ArraySet had a collation prior to - // serialization. - auto collated = buf.read<char>(); - auto [arrTag, arrVal] = makeNewArraySet(collated ? collator : nullptr); auto cnt = buf.read<LittleEndian<size_t>>(); + auto [arrTag, arrVal] = makeNewArraySet(); auto arr = getArraySetView(arrVal); if (cnt) { arr->reserve(cnt); for (size_t idx = 0; idx < cnt; ++idx) { - auto [tag, val] = deserializeValue(buf, collator); + auto [tag, val] = deserializeValue(buf); arr->push_back(tag, val); } } @@ -143,7 +138,7 @@ static std::pair<TypeTags, Value> deserializeValue(BufReader& buf, obj->reserve(cnt); for (size_t idx = 0; idx < cnt; ++idx) { auto fieldName = buf.readCStr(); - auto [tag, val] = deserializeValue(buf, collator); + auto [tag, val] = deserializeValue(buf); obj->push_back(fieldName, tag, val); } } @@ -218,12 +213,12 @@ static std::pair<TypeTags, Value> deserializeValue(BufReader& buf, } MaterializedRow MaterializedRow::deserializeForSorter(BufReader& buf, - const SorterDeserializeSettings& settings) { + const SorterDeserializeSettings&) { auto cnt = buf.read<LittleEndian<size_t>>(); MaterializedRow result{cnt}; for (size_t idx = 0; idx < cnt; ++idx) { - auto [tag, val] = deserializeValue(buf, settings.collator); + auto [tag, val] = deserializeValue(buf); result.reset(idx, true, tag, val); } @@ -293,12 +288,6 @@ static void serializeValue(BufBuilder& buf, TypeTags tag, Value val) { } case TypeTags::ArraySet: { auto arr = getArraySetView(val); - // If an ArraySet has a collation, we serialize a byte which acts as a flag as to - // whether the set should be created with a collation upon deserialization. Also, we - // assume that the caller which does deserialization will have the context about what - // the collation is, and therefore we can save space by not serializing the full - // description of the collation. - buf.appendChar(arr->getCollator() ? 1 : 0); buf.appendNum(arr->size()); for (auto& kv : arr->values()) { serializeValue(buf, kv.first, kv.second); @@ -382,22 +371,7 @@ static void serializeValue(BufBuilder& buf, TypeTags tag, Value val) { } } -/** - * If non-null 'collator' is provided during serialization, then the encoding guarantees that values - * which are equal up to the collation will encode to the same result, allowing for collation-aware - * equality comparisons. However, the collator-aware encoded values are not always decodable. Groups - * store an original copy of the group key alongside the encoded key string when there is a - * collation, so the key string does not need to be decodable. - */ -static void serializeValueIntoKeyString(KeyString::Builder& buf, - TypeTags tag, - Value val, - const CollatorInterface* collator) { - - const auto stringTransformFn = [&](StringData stringData) { - return collator->getComparisonString(stringData); - }; - +static void serializeValueIntoKeyString(KeyString::Builder& buf, TypeTags tag, Value val) { switch (tag) { case TypeTags::Nothing: { buf.appendBool(false); @@ -460,21 +434,19 @@ static void serializeValueIntoKeyString(KeyString::Builder& buf, buf.appendUndefined(); break; } - case TypeTags::StringSmall: + case TypeTags::StringSmall: { + // Small strings cannot contain null bytes, so it is safe to serialize them as plain + // C-strings with a null terminator. + buf.appendBool(true); + buf.appendString(getStringView(tag, val)); + break; + } case TypeTags::StringBig: case TypeTags::bsonString: { buf.appendBool(true); - if (collator) { - buf.appendString(getStringView(tag, val), stringTransformFn); - } else { - buf.appendString(getStringView(tag, val)); - } + buf.appendString(getStringOrSymbolView(tag, val)); break; } - // Note that the collation would have to apply to bsonSymbol values to match the - // behavior of the Classic engine when spilling groups to disk. bsonSymbol is - // deprecated, however, and SBE no longer provides strict correctness guarantees about - // computations on bsonSymbol values. case TypeTags::bsonSymbol: { buf.appendBool(true); buf.appendSymbol(getStringOrSymbolView(tag, val)); @@ -485,13 +457,9 @@ static void serializeValueIntoKeyString(KeyString::Builder& buf, // TODO SERVER-61629: convert this to serialize the 'arr' directly instead of // constructing a BSONArray. BSONArrayBuilder builder; - bson::convertToBsonObj(builder, value::ArrayEnumerator{tag, val}); + bson::convertToBsonObj(builder, getArrayView(val)); buf.appendBool(true); - if (collator) { - buf.appendArray(builder.arr(), stringTransformFn); - } else { - buf.appendArray(builder.arr()); - } + buf.appendArray(BSONArray(builder.done())); break; } case TypeTags::Object: { @@ -500,37 +468,27 @@ static void serializeValueIntoKeyString(KeyString::Builder& buf, BSONObjBuilder builder; bson::convertToBsonObj(builder, getObjectView(val)); buf.appendBool(true); - if (collator) { - buf.appendObject(builder.done(), stringTransformFn); - } else { - buf.appendObject(builder.done()); - } + buf.appendObject(builder.done()); break; } - case TypeTags::bsonObjectId: case TypeTags::ObjectId: { buf.appendBool(true); - buf.appendOID(OID::from(getRawPointerView(val))); + buf.appendBytes(getObjectIdView(val), sizeof(ObjectIdType)); break; } case TypeTags::bsonObject: { - BSONObj bson{getRawPointerView(val)}; buf.appendBool(true); - if (collator) { - buf.appendObject(bson, stringTransformFn); - } else { - buf.appendObject(bson); - } + buf.appendObject(BSONObj(getRawPointerView(val))); break; } case TypeTags::bsonArray: { - BSONObj bson{getRawPointerView(val)}; buf.appendBool(true); - if (collator) { - buf.appendArray(BSONArray(BSONObj(bson)), stringTransformFn); - } else { - buf.appendArray(BSONArray(BSONObj(bson))); - } + buf.appendArray(BSONArray(BSONObj(getRawPointerView(val)))); + break; + } + case TypeTags::bsonObjectId: { + buf.appendBool(true); + buf.appendOID(OID::from(getRawPointerView(val))); break; } case TypeTags::bsonBinData: { @@ -599,18 +557,15 @@ void MaterializedRow::serializeForSorter(BufBuilder& buf) const { } } -void MaterializedRow::serializeIntoKeyString(KeyString::Builder& buf, - const CollatorInterface* collator) const { +void MaterializedRow::serializeIntoKeyString(KeyString::Builder& buf) const { for (size_t idx = 0; idx < size(); ++idx) { auto [tag, val] = getViewOfValue(idx); - serializeValueIntoKeyString(buf, tag, val, collator); + serializeValueIntoKeyString(buf, tag, val); } } -MaterializedRow MaterializedRow::deserializeFromKeyString( - const KeyString::Value& keyString, - BufBuilder* valueBufferBuilder, - boost::optional<size_t> numPrefixValsToRead) { +MaterializedRow MaterializedRow::deserializeFromKeyString(const KeyString::Value& keyString, + BufBuilder* valueBufferBuilder) { BufReader reader(keyString.getBuffer(), keyString.getSize()); KeyString::TypeBits typeBits(keyString.getTypeBits()); KeyString::TypeBits::Reader typeBitsReader(typeBits); @@ -622,8 +577,7 @@ MaterializedRow MaterializedRow::deserializeFromKeyString( &reader, &typeBitsReader, false /* inverted */, typeBits.version, &valBuilder); } while (keepReading); - size_t sizeOfRow = numPrefixValsToRead ? *numPrefixValsToRead : valBuilder.numValues(); - MaterializedRow result{sizeOfRow}; + MaterializedRow result{valBuilder.numValues()}; valBuilder.readValues(result); return result; diff --git a/src/mongo/db/exec/sbe/values/slot.h b/src/mongo/db/exec/sbe/values/slot.h index e682b2bfeb8..f853f816d4d 100644 --- a/src/mongo/db/exec/sbe/values/slot.h +++ b/src/mongo/db/exec/sbe/values/slot.h @@ -468,11 +468,8 @@ public: } // The following methods are used by the sorter only. - struct SorterDeserializeSettings { - const CollatorInterface* collator{nullptr}; - }; - static MaterializedRow deserializeForSorter(BufReader& buf, - const SorterDeserializeSettings& settings); + struct SorterDeserializeSettings {}; + static MaterializedRow deserializeForSorter(BufReader& buf, const SorterDeserializeSettings&); void serializeForSorter(BufBuilder& buf) const; int memUsageForSorter() const; auto getOwned() const { @@ -486,21 +483,11 @@ public: * intended for spilling key values used in the HashAgg stage. The format is not guaranteed to * be stable between versions, so it should not be used for long-term storage or communication * between instances. - * - * If 'numPrefixValsToRead' is provided, then only the given number of values from 'keyString' - * are decoded into the resulting 'MaterializedRow'. The remaining suffix values in the - * 'keyString' are ignored. - * - * If non-null 'collator' is provided during serialization, then any strings in the row are - * encoded as ICU collation keys prior to being KeyString-encoded. */ - static MaterializedRow deserializeFromKeyString( - const KeyString::Value& keyString, - BufBuilder* valueBufferBuilder, - boost::optional<size_t> numPrefixValsToRead = boost::none); + static MaterializedRow deserializeFromKeyString(const KeyString::Value& keyString, - void serializeIntoKeyString(KeyString::Builder& builder, - const CollatorInterface* collator = nullptr) const; + BufBuilder* valueBufferBuilder); + void serializeIntoKeyString(KeyString::Builder& builder) const; private: static size_t sizeInBytes(size_t count) { @@ -590,9 +577,9 @@ private: }; struct MaterializedRowEq { - using ComparatorType = StringData::ComparatorInterface; + using ComparatorType = StringData::ComparatorInterface*; - explicit MaterializedRowEq(const ComparatorType* comparator = nullptr) + explicit MaterializedRowEq(const ComparatorType comparator = nullptr) : _comparator(comparator) {} bool operator()(const MaterializedRow& lhs, const MaterializedRow& rhs) const { @@ -610,7 +597,7 @@ struct MaterializedRowEq { } private: - const ComparatorType* _comparator = nullptr; + const ComparatorType _comparator = nullptr; }; struct MaterializedRowLess { diff --git a/src/mongo/db/exec/sbe/values/value.cpp b/src/mongo/db/exec/sbe/values/value.cpp index e0f73c87ddf..6c21f4f6e5d 100644 --- a/src/mongo/db/exec/sbe/values/value.cpp +++ b/src/mongo/db/exec/sbe/values/value.cpp @@ -860,7 +860,7 @@ bool isInfinity(TypeTags tag, Value val) { (tag == TypeTags::NumberDecimal && bitcastTo<Decimal128>(val).isInfinite()); } -bool ArraySet::push_back(TypeTags tag, Value val) { +void ArraySet::push_back(TypeTags tag, Value val) { if (tag != TypeTags::Nothing) { ValueGuard guard{tag, val}; auto [it, inserted] = _values.insert({tag, val}); @@ -868,11 +868,7 @@ bool ArraySet::push_back(TypeTags tag, Value val) { if (inserted) { guard.reset(); } - - return inserted; } - - return false; } std::pair<TypeTags, Value> ArrayEnumerator::getViewOfValue() const { diff --git a/src/mongo/db/exec/sbe/values/value.h b/src/mongo/db/exec/sbe/values/value.h index ae207106d8b..26ba3e5e1de 100644 --- a/src/mongo/db/exec/sbe/values/value.h +++ b/src/mongo/db/exec/sbe/values/value.h @@ -844,14 +844,7 @@ public: } } - /** - * Adds the given SBE value to the set if an equal value is not already present. Assumes - * ownership of the given value. - * - * Returns true if the value was newly inserted, otherwise returns false to indicate that an - * equal value was already present in the set. - */ - bool push_back(TypeTags tag, Value val); + void push_back(TypeTags tag, Value val); auto& values() const noexcept { return _values; diff --git a/src/mongo/db/exec/sbe/values/value_builder.h b/src/mongo/db/exec/sbe/values/value_builder.h index 00333e9f824..9ad2b511242 100644 --- a/src/mongo/db/exec/sbe/values/value_builder.h +++ b/src/mongo/db/exec/sbe/values/value_builder.h @@ -191,11 +191,8 @@ public: virtual size_t numValues() const = 0; protected: - // We expect most rows to end up containing this many values or fewer. - static constexpr int kInlinedVectorSize = 16; - std::pair<TypeTags, Value> getValue(size_t index, int bufferLen) { - invariant(index < _tagList.size()); + invariant(index < _numValues); auto tag = _tagList[index]; auto val = _valList[index]; @@ -227,8 +224,9 @@ protected: } void appendValue(TypeTags tag, Value val) noexcept { - _tagList.push_back(tag); - _valList.push_back(val); + _tagList[_numValues] = tag; + _valList[_numValues] = val; + ++_numValues; } void appendValue(std::pair<TypeTags, Value> in) noexcept { @@ -243,12 +241,14 @@ protected: // storing a pointer, we store an _offset_ into the under-construction buffer. Translation from // offset to pointer occurs as part of the 'readValues()' function. void appendValueBufferOffset(TypeTags tag) { - _tagList.push_back(tag); - _valList.push_back(value::bitcastFrom<int32_t>(_valueBufferBuilder->len())); + _tagList[_numValues] = tag; + _valList[_numValues] = value::bitcastFrom<int32_t>(_valueBufferBuilder->len()); + ++_numValues; } - absl::InlinedVector<TypeTags, kInlinedVectorSize> _tagList; - absl::InlinedVector<Value, kInlinedVectorSize> _valList; + std::array<TypeTags, Ordering::kMaxCompoundIndexKeys> _tagList; + std::array<Value, Ordering::kMaxCompoundIndexKeys> _valList; + size_t _numValues = 0; BufBuilder* _valueBufferBuilder; }; @@ -270,12 +270,11 @@ public: // buffer, this value will remain in that buffer, even though we've removed it from the // list. It will still get deallocated along with everything else when that buffer gets // cleared or deleted, though, so there is no leak. - _tagList.pop_back(); - _valList.pop_back(); + --_numValues; } size_t numValues() const override { - return _tagList.size(); + return _numValues; } /** @@ -285,7 +284,7 @@ public: */ void readValues(std::vector<OwnedValueAccessor>* accessors) { auto bufferLen = _valueBufferBuilder->len(); - for (size_t i = 0; i < _tagList.size(); ++i) { + for (size_t i = 0; i < _numValues; ++i) { auto [tag, val] = getValue(i, bufferLen); invariant(i < accessors->size()); (*accessors)[i].reset(false, tag, val); @@ -305,7 +304,7 @@ public: size_t numValues() const override { size_t nVals = 0; size_t bufIdx = 0; - while (bufIdx < _tagList.size()) { + while (bufIdx < _numValues) { auto tag = _tagList[bufIdx]; auto val = _valList[bufIdx]; if (tag == TypeTags::Boolean && !bitcastTo<bool>(val)) { @@ -324,10 +323,7 @@ public: auto bufferLen = _valueBufferBuilder->len(); size_t bufIdx = 0; size_t rowIdx = 0; - // The 'row' output parameter might be smaller than the number of values owned by this - // builder. Be careful to only read as many values into 'row' as this output 'row' has space - // for. - while (rowIdx < row.size()) { + while (bufIdx < _numValues) { invariant(rowIdx < row.size()); auto [_, tagNothing, valNothing] = getValue(bufIdx++, bufferLen); tassert(6136200, "sbe tag must be 'Boolean'", tagNothing == TypeTags::Boolean); diff --git a/src/mongo/db/exec/sbe/values/value_serialization_test.cpp b/src/mongo/db/exec/sbe/values/value_serialization_test.cpp index ceacf610a4a..5b44bef6549 100644 --- a/src/mongo/db/exec/sbe/values/value_serialization_test.cpp +++ b/src/mongo/db/exec/sbe/values/value_serialization_test.cpp @@ -268,18 +268,6 @@ TEST_F(ValueSerializeForKeyString, SbeArray) { runTest({{testDataTag, testDataVal}}); } -TEST_F(ValueSerializeForKeyString, ArraySet) { - auto [tag, val] = sbe::value::makeNewArraySet(); - sbe::value::ValueGuard guard{tag, val}; - auto* arraySet = sbe::value::getArraySetView(val); - - arraySet->push_back(value::TypeTags::NumberInt32, value::bitcastFrom<int32_t>(1)); - arraySet->push_back(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(2)); - arraySet->push_back(value::TypeTags::NumberDouble, value::bitcastFrom<double>(3.0)); - - runTest({{tag, val}}); -} - TEST_F(ValueSerializeForKeyString, DateTime) { runTest({{value::TypeTags::Date, value::bitcastFrom<int64_t>(1234)}, {value::TypeTags::Timestamp, value::bitcastFrom<uint64_t>(5678)}}); @@ -454,30 +442,4 @@ TEST_F(ValueSerializeForKeyString, BsonCodeWScope) { runTest({{cwsTag1, cwsVal1}, {cwsTag2, cwsVal2}, {cwsTag3, cwsVal3}}); } - -// Test that roundtripping through KeyString works for a wide row. KeyStrings used in indexes are -// typically constrained in the number of components they can have, since we limit compound indexes -// to at most 32 components. But roundtripping rows wider than 32 still needs to work. -// -// This test was originally designed to reproduce SERVER-76321. -TEST_F(ValueSerializeForKeyString, RoundtripWideRow) { - std::vector<std::pair<sbe::value::TypeTags, sbe::value::Value>> row; - for (int32_t i = 0; i < 40; ++i) { - row.emplace_back(sbe::value::TypeTags::NumberInt32, sbe::value::bitcastFrom<int32_t>(i)); - } - runTest(row); -} - -// Test that roundtripping through KeyString works for ObjectIdType: ObjectId; bsonObjectId. -TEST_F(ValueSerializeForKeyString, RoundtripObjectIdType) { - auto [objectIdTag, objectIdVal] = value::makeNewObjectId(); - - auto oid = OID::gen(); - auto obj = BSON("" << oid); - auto oidStorage = obj.firstElement().value(); - - sbe::value::ValueGuard testDataGuard{objectIdTag, objectIdVal}; - runTest({{objectIdTag, objectIdVal}, - {value::TypeTags::bsonObjectId, value::bitcastFrom<const char*>(oidStorage)}}); -} } // namespace mongo::sbe diff --git a/src/mongo/db/exec/sbe/vm/arith.cpp b/src/mongo/db/exec/sbe/vm/arith.cpp index e6c9d380ffd..e4c67775ad8 100644 --- a/src/mongo/db/exec/sbe/vm/arith.cpp +++ b/src/mongo/db/exec/sbe/vm/arith.cpp @@ -503,57 +503,6 @@ void ByteCode::aggDoubleDoubleSumImpl(value::Array* arr, } } -void ByteCode::aggMergeDoubleDoubleSumsImpl(value::Array* accumulator, - value::TypeTags rhsTag, - value::Value rhsValue) { - auto [accumWidestType, _1] = accumulator->getAt(AggSumValueElems::kNonDecimalTotalTag); - - tassert(7039532, "value must be of type 'Array'", rhsTag == value::TypeTags::Array); - auto nextDoubleDoubleArr = value::getArrayView(rhsValue); - - tassert(7039533, - "array does not have enough elements", - nextDoubleDoubleArr->size() >= AggSumValueElems::kMaxSizeOfArray - 1); - - // First aggregate the non-decimal sum, then the non-decimal addend. Both should be doubles. - auto [sumTag, sum] = nextDoubleDoubleArr->getAt(AggSumValueElems::kNonDecimalTotalSum); - tassert(7039534, "expected 'NumberDouble'", sumTag == value::TypeTags::NumberDouble); - aggDoubleDoubleSumImpl(accumulator, sumTag, sum); - - auto [addendTag, addend] = nextDoubleDoubleArr->getAt(AggSumValueElems::kNonDecimalTotalAddend); - tassert(7039535, "expected 'NumberDouble'", addendTag == value::TypeTags::NumberDouble); - // There is a special case when the 'sum' is infinite and the 'addend' is NaN. This DoubleDouble - // value represents infinity, not NaN. Therefore, we avoid incorporating the NaN 'addend' value - // into the sum. - if (std::isfinite(value::bitcastTo<double>(sum)) || - !std::isnan(value::bitcastTo<double>(addend))) { - aggDoubleDoubleSumImpl(accumulator, addendTag, addend); - } - - // Determine the widest non-decimal type that we've seen so far, and set the accumulator state - // accordingly. We do this after computing the sums, since 'aggDoubleDoubleSumImpl()' will - // set the widest type to 'NumberDouble' when we call it above. - auto [newValWidestType, _2] = nextDoubleDoubleArr->getAt(AggSumValueElems::kNonDecimalTotalTag); - tassert( - 7039536, "unexpected 'NumberDecimal'", newValWidestType != value::TypeTags::NumberDecimal); - tassert( - 7039537, "unexpected 'NumberDecimal'", accumWidestType != value::TypeTags::NumberDecimal); - auto widestType = getWidestNumericalType(newValWidestType, accumWidestType); - accumulator->setAt( - AggSumValueElems::kNonDecimalTotalTag, widestType, value::bitcastFrom<int32_t>(0)); - - // If there's a decimal128 sum as part of the incoming DoubleDouble sum, incorporate it into the - // accumulator. - if (nextDoubleDoubleArr->size() == AggSumValueElems::kMaxSizeOfArray) { - auto [decimalTotalTag, decimalTotalVal] = - nextDoubleDoubleArr->getAt(AggSumValueElems::kDecimalTotal); - tassert(7039538, - "The decimalTotal must be 'NumberDecimal'", - decimalTotalTag == TypeTags::NumberDecimal); - aggDoubleDoubleSumImpl(accumulator, decimalTotalTag, decimalTotalVal); - } -} - void ByteCode::aggStdDevImpl(value::Array* arr, value::TypeTags rhsTag, value::Value rhsValue) { if (!isNumber(rhsTag)) { return; @@ -602,67 +551,6 @@ void ByteCode::aggStdDevImpl(value::Array* arr, value::TypeTags rhsTag, value::V return setStdDevArray(newCountVal, newMeanVal, newM2Val, arr); } -void ByteCode::aggMergeStdDevsImpl(value::Array* accumulator, - value::TypeTags rhsTag, - value::Value rhsValue) { - tassert(7039542, "expected value of type 'Array'", rhsTag == value::TypeTags::Array); - auto nextArr = value::getArrayView(rhsValue); - - tassert(7039543, - "expected array to have exactly 3 elements", - accumulator->size() == AggStdDevValueElems::kSizeOfArray); - tassert(7039544, - "expected array to have exactly 3 elements", - nextArr->size() == AggStdDevValueElems::kSizeOfArray); - - auto [newCountTag, newCountVal] = nextArr->getAt(AggStdDevValueElems::kCount); - tassert(7039545, "expected 64-bit int", newCountTag == value::TypeTags::NumberInt64); - int64_t newCount = value::bitcastTo<int64_t>(newCountVal); - - // If the incoming partial aggregate has a count of zero, then it represents the partial - // standard deviation of no data points. This means that it can be safely ignored, and we return - // the accumulator as is. - if (newCount == 0) { - return; - } - - auto [oldCountTag, oldCountVal] = accumulator->getAt(AggStdDevValueElems::kCount); - tassert(7039546, "expected 64-bit int", oldCountTag == value::TypeTags::NumberInt64); - int64_t oldCount = value::bitcastTo<int64_t>(oldCountVal); - - auto [oldMeanTag, oldMeanVal] = accumulator->getAt(AggStdDevValueElems::kRunningMean); - tassert(7039547, "expected double", oldMeanTag == value::TypeTags::NumberDouble); - double oldMean = value::bitcastTo<double>(oldMeanVal); - - auto [newMeanTag, newMeanVal] = nextArr->getAt(AggStdDevValueElems::kRunningMean); - tassert(7039548, "expected double", newMeanTag == value::TypeTags::NumberDouble); - double newMean = value::bitcastTo<double>(newMeanVal); - - auto [oldM2Tag, oldM2Val] = accumulator->getAt(AggStdDevValueElems::kRunningM2); - tassert(7039531, "expected double", oldM2Tag == value::TypeTags::NumberDouble); - double oldM2 = value::bitcastTo<double>(oldM2Val); - - auto [newM2Tag, newM2Val] = nextArr->getAt(AggStdDevValueElems::kRunningM2); - tassert(7039541, "expected double", newM2Tag == value::TypeTags::NumberDouble); - double newM2 = value::bitcastTo<double>(newM2Val); - - const double delta = newMean - oldMean; - // We've already handled the case where 'newCount' is zero above. This means that 'totalCount' - // must be positive, and prevents us from ever dividing by zero in the subsequent calculation. - int64_t totalCount = oldCount + newCount; - if (delta != 0) { - newMean = ((oldCount * oldMean) + (newCount * newMean)) / totalCount; - newM2 += delta * delta * - (static_cast<double>(oldCount) * static_cast<double>(newCount) / totalCount); - } - newM2 += oldM2; - - setStdDevArray(value::bitcastFrom<int64_t>(totalCount), - value::bitcastFrom<double>(newMean), - value::bitcastFrom<double>(newM2), - accumulator); -} - std::tuple<bool, value::TypeTags, value::Value> ByteCode::aggStdDevFinalizeImpl( value::Value fieldValue, bool isSamp) { auto arr = value::getArrayView(fieldValue); @@ -1027,7 +915,7 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::genericLn(value::TypeT if (!operand.isGreater(Decimal128::kNormalizedZero) && !operand.isNaN()) { return {false, value::TypeTags::Nothing, 0}; } - auto operandLn = operand.naturalLogarithm(); + auto operandLn = operand.logarithm(); auto [tag, value] = value::makeCopyDecimal(operandLn); return {true, tag, value}; diff --git a/src/mongo/db/exec/sbe/vm/vm.cpp b/src/mongo/db/exec/sbe/vm/vm.cpp index 812de5232af..7eb8eb7149e 100644 --- a/src/mongo/db/exec/sbe/vm/vm.cpp +++ b/src/mongo/db/exec/sbe/vm/vm.cpp @@ -1072,40 +1072,35 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::aggSum(value::TypeTags return genericAdd(accTag, accValue, fieldTag, fieldValue); } -template <bool merging> std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggDoubleDoubleSum( ArityType arity) { + auto [_, fieldTag, fieldValue] = getFromStack(1); // Move the incoming accumulator state from the stack. Given that we are now the owner of the // state we are free to do any in-place update as we see fit. auto [accTag, accValue] = moveOwnedFromStack(0); + value::ValueGuard guard{accTag, accValue}; // Initialize the accumulator. if (accTag == value::TypeTags::Nothing) { std::tie(accTag, accValue) = value::makeNewArray(); - value::ValueGuard newArrGuard{accTag, accValue}; + value::ValueGuard guard{accTag, accValue}; auto arr = value::getArrayView(accValue); arr->reserve(AggSumValueElems::kMaxSizeOfArray); - // The order of the following three elements should match to 'AggSumValueElems'. An absent - // 'kDecimalTotal' element means that we've not seen any decimal value. So, we're not adding - // 'kDecimalTotal' element yet. + // The order of the following three elements should match to 'AggSumValueElems'. arr->push_back(value::TypeTags::NumberInt32, value::bitcastFrom<int32_t>(0)); arr->push_back(value::TypeTags::NumberDouble, value::bitcastFrom<double>(0.0)); arr->push_back(value::TypeTags::NumberDouble, value::bitcastFrom<double>(0.0)); - newArrGuard.reset(); + // The absent 'kDecimalTotal' element means that we've not seen any decimal value. So, we're + // not adding 'kDecimalTotal' element yet. + aggDoubleDoubleSumImpl(arr, fieldTag, fieldValue); + guard.reset(); + return {true, accTag, accValue}; } - - value::ValueGuard guard{accTag, accValue}; tassert(5755317, "The result slot must be Array-typed", accTag == value::TypeTags::Array); - auto accumulator = value::getArrayView(accValue); - - if constexpr (merging) { - aggMergeDoubleDoubleSumsImpl(accumulator, fieldTag, fieldValue); - } else { - aggDoubleDoubleSumImpl(accumulator, fieldTag, fieldValue); - } + aggDoubleDoubleSumImpl(value::getArrayView(accValue), fieldTag, fieldValue); guard.reset(); return {true, accTag, accValue}; } @@ -1240,37 +1235,31 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinDoubleDoublePar return {true, tag, val}; } -template <bool merging> std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggStdDev(ArityType arity) { auto [_, fieldTag, fieldValue] = getFromStack(1); // Move the incoming accumulator state from the stack. Given that we are now the owner of the // state we are free to do any in-place update as we see fit. auto [accTag, accValue] = moveOwnedFromStack(0); + value::ValueGuard guard{accTag, accValue}; // Initialize the accumulator. if (accTag == value::TypeTags::Nothing) { - std::tie(accTag, accValue) = value::makeNewArray(); - value::ValueGuard newArrGuard{accTag, accValue}; - auto arr = value::getArrayView(accValue); + auto [newAccTag, newAccValue] = value::makeNewArray(); + value::ValueGuard newGuard{newAccTag, newAccValue}; + auto arr = value::getArrayView(newAccValue); arr->reserve(AggStdDevValueElems::kSizeOfArray); // The order of the following three elements should match to 'AggStdDevValueElems'. arr->push_back(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(0)); arr->push_back(value::TypeTags::NumberDouble, value::bitcastFrom<double>(0.0)); arr->push_back(value::TypeTags::NumberDouble, value::bitcastFrom<double>(0.0)); - newArrGuard.reset(); + aggStdDevImpl(arr, fieldTag, fieldValue); + newGuard.reset(); + return {true, newAccTag, newAccValue}; } - - value::ValueGuard guard{accTag, accValue}; tassert(5755210, "The result slot must be Array-typed", accTag == value::TypeTags::Array); - auto accumulator = value::getArrayView(accValue); - - if constexpr (merging) { - aggMergeStdDevsImpl(accumulator, fieldTag, fieldValue); - } else { - aggStdDevImpl(accumulator, fieldTag, fieldValue); - } + aggStdDevImpl(value::getArrayView(accValue), fieldTag, fieldValue); guard.reset(); return {true, accTag, accValue}; } @@ -3030,120 +3019,6 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinConcat(ArityTyp return {true, strTag, strValue}; } -std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinConcatArrays(ArityType arity) { - auto [resTag, resVal] = value::makeNewArray(); - value::ValueGuard resGuard{resTag, resVal}; - auto resView = value::getArrayView(resVal); - - for (ArityType idx = 0; idx < arity; ++idx) { - auto [_, tag, val] = getFromStack(idx); - if (!value::isArray(tag)) { - return {false, value::TypeTags::Nothing, 0}; - } - - for (auto ae = value::ArrayEnumerator{tag, val}; !ae.atEnd(); ae.advance()) { - auto [elTag, elVal] = ae.getViewOfValue(); - auto [copyTag, copyVal] = value::copyValue(elTag, elVal); - resView->push_back(copyTag, copyVal); - } - } - - resGuard.reset(); - - return {true, resTag, resVal}; -} - -std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggConcatArraysCapped( - ArityType arity) { - auto [ownArr, tagArr, valArr] = getFromStack(0); - auto [tagNewElem, valNewElem] = moveOwnedFromStack(1); - value::ValueGuard guardNewElem{tagNewElem, valNewElem}; - auto [_, tagSizeCap, valSizeCap] = getFromStack(2); - - tassert(7039508, - "'cap' parameter must be a 32-bit int", - tagSizeCap == value::TypeTags::NumberInt32); - const int32_t sizeCap = value::bitcastTo<int32_t>(valSizeCap); - - // We expect the new value we are adding to the accumulator to be a two-element array where - // the first element is the array to concatenate and the second value is the corresponding size. - tassert(7039512, "expected value of type 'Array'", tagNewElem == value::TypeTags::Array); - auto newArr = value::getArrayView(valNewElem); - tassert(7039527, - "array had unexpected size", - newArr->size() == static_cast<size_t>(AggArrayWithSize::kLast)); - - // Create a new array to hold size and added elements, if is it does not exist yet. - if (tagArr == value::TypeTags::Nothing) { - ownArr = true; - std::tie(tagArr, valArr) = value::makeNewArray(); - auto arr = value::getArrayView(valArr); - - auto [tagAccArr, valAccArr] = value::makeNewArray(); - - // The order is important! The accumulated array should be at index - // AggArrayWithSize::kValues, and the size should be at index - // AggArrayWithSize::kSizeOfValues. - arr->push_back(tagAccArr, valAccArr); - arr->push_back(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(0)); - } else { - // Take ownership of the accumulator. - topStack(false, value::TypeTags::Nothing, 0); - } - - tassert(7039513, "expected array to be owned", ownArr); - value::ValueGuard accumulatorGuard{tagArr, valArr}; - tassert(7039514, "expected accumulator to have type 'Array'", tagArr == value::TypeTags::Array); - auto arr = value::getArrayView(valArr); - tassert(7039515, - "accumulator was array of unexpected size", - arr->size() == static_cast<size_t>(AggArrayWithSize::kLast)); - - // Check that the accumulated size after concatentation won't exceed the limit. - { - auto [tagAccSize, valAccSize] = - arr->getAt(static_cast<size_t>(AggArrayWithSize::kSizeOfValues)); - auto [tagNewSize, valNewSize] = - newArr->getAt(static_cast<size_t>(AggArrayWithSize::kSizeOfValues)); - tassert(7039516, "expected 64-bit int", tagAccSize == value::TypeTags::NumberInt64); - tassert(7039517, "expected 64-bit int", tagNewSize == value::TypeTags::NumberInt64); - const int64_t currentSize = value::bitcastTo<int64_t>(valAccSize); - const int64_t newSize = value::bitcastTo<int64_t>(valNewSize); - const int64_t totalSize = currentSize + newSize; - - if (totalSize >= static_cast<int64_t>(sizeCap)) { - uasserted(ErrorCodes::ExceededMemoryLimit, - str::stream() << "Used too much memory for a single array. Memory limit: " - << sizeCap << ". Concatentating array of " << arr->size() - << " elements and " << currentSize << " bytes with array of " - << newArr->size() << " elements and " << newSize << " bytes."); - } - - // We are still under the size limit. Set the new total size in the accumulator. - arr->setAt(static_cast<size_t>(AggArrayWithSize::kSizeOfValues), - value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(totalSize)); - } - - auto [tagAccArr, valAccArr] = arr->getAt(static_cast<size_t>(AggArrayWithSize::kValues)); - tassert(7039518, "expected value of type 'Array'", tagAccArr == value::TypeTags::Array); - auto accArr = value::getArrayView(valAccArr); - - auto [tagNewArray, valNewArray] = newArr->getAt(static_cast<size_t>(AggArrayWithSize::kValues)); - tassert(7039519, "expected value of type 'Array'", tagNewArray == value::TypeTags::Array); - - for (auto i = value::ArrayEnumerator{tagNewArray, valNewArray}; !i.atEnd(); i.advance()) { - auto [elTag, elVal] = i.getViewOfValue(); - // TODO SERVER-71952: Since 'valNewArray' is owned here, in the future we could avoid this - // copy by moving the element out of the array. - auto [copyTag, copyVal] = value::copyValue(elTag, elVal); - accArr->push_back(copyTag, copyVal); - } - - accumulatorGuard.reset(); - return {ownArr, tagArr, valArr}; -} - std::pair<value::TypeTags, value::Value> ByteCode::genericIsMember(value::TypeTags lhsTag, value::Value lhsVal, value::TypeTags rhsTag, @@ -3521,166 +3396,6 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinSetUnion(ArityT return setUnion(argTags, argVals); } -std::tuple<bool, value::TypeTags, value::Value> ByteCode::aggSetUnionCappedImpl( - value::TypeTags tagNewElem, - value::Value valNewElem, - int32_t sizeCap, - CollatorInterface* collator) { - value::ValueGuard guardNewElem{tagNewElem, valNewElem}; - auto [ownAcc, tagAcc, valAcc] = getFromStack(0); - - // We expect the new value we are adding to the accumulator to be a two-element array where - // the first element is the new set of values and the second value is the corresponding size. - tassert(7039526, "expected value of type 'Array'", tagNewElem == value::TypeTags::Array); - auto newArr = value::getArrayView(valNewElem); - tassert(7039528, - "array had unexpected size", - newArr->size() == static_cast<size_t>(AggArrayWithSize::kLast)); - - // Create a new array is it does not exist yet. - if (tagAcc == value::TypeTags::Nothing) { - ownAcc = true; - std::tie(tagAcc, valAcc) = value::makeNewArray(); - auto accArray = value::getArrayView(valAcc); - - auto [tagAccSet, valAccSet] = value::makeNewArraySet(collator); - - // The order is important! The accumulated array should be at index - // AggArrayWithSize::kValues, and the size should be at index - // AggArrayWithSize::kSizeOfValues. - accArray->push_back(tagAccSet, valAccSet); - accArray->push_back(value::TypeTags::NumberInt64, value::bitcastFrom<int64_t>(0)); - } else { - // Take ownership of the accumulator. - topStack(false, value::TypeTags::Nothing, 0); - } - - tassert(7039520, "expected accumulator value to be owned", ownAcc); - value::ValueGuard guardArr{tagAcc, valAcc}; - - tassert( - 7039521, "expected accumulator to be of type 'Array'", tagAcc == value::TypeTags::Array); - auto accArray = value::getArrayView(valAcc); - tassert(7039522, - "array had unexpected size", - accArray->size() == static_cast<size_t>(AggArrayWithSize::kLast)); - - auto [tagAccArrSet, valAccArrSet] = - accArray->getAt(static_cast<size_t>(AggArrayWithSize::kValues)); - tassert( - 7039523, "expected value of type 'ArraySet'", tagAccArrSet == value::TypeTags::ArraySet); - auto accArrSet = value::getArraySetView(valAccArrSet); - - // Extract the current size of the accumulator. As we add elements to the set, we will increment - // the current size accordingly and throw an exception if we ever exceed the size limit. We - // cannot simply sum the two sizes, since the two sets could have a substantial intersection. - auto [tagAccSize, valAccSize] = - accArray->getAt(static_cast<size_t>(AggArrayWithSize::kSizeOfValues)); - tassert(7039524, "expected 64-bit int", tagAccSize == value::TypeTags::NumberInt64); - int64_t currentSize = value::bitcastTo<int64_t>(valAccSize); - - auto [tagNewValSet, valNewValSet] = - newArr->getAt(static_cast<size_t>(AggArrayWithSize::kValues)); - tassert( - 7039525, "expected value of type 'ArraySet'", tagNewValSet == value::TypeTags::ArraySet); - - for (auto i = value::ArrayEnumerator{tagNewValSet, valNewValSet}; !i.atEnd(); i.advance()) { - auto [elTag, elVal] = i.getViewOfValue(); - int elemSize = value::getApproximateSize(elTag, elVal); - // TODO SERVER-71952: Since 'valNewValSet' is owned here, in the future we could avoid this - // copy by moving the element out of the array. - auto [copyTag, copyVal] = value::copyValue(elTag, elVal); - bool inserted = accArrSet->push_back(copyTag, copyVal); - - if (inserted) { - currentSize += elemSize; - if (currentSize >= static_cast<int64_t>(sizeCap)) { - uasserted(ErrorCodes::ExceededMemoryLimit, - str::stream() << "Used too much memory for a single array. Memory limit: " - << sizeCap << ". Current set has " << accArrSet->size() - << " elements and is " << currentSize << " bytes."); - } - } - } - - // Update the accumulator with the new total size. - accArray->setAt(static_cast<size_t>(AggArrayWithSize::kSizeOfValues), - value::TypeTags::NumberInt64, - value::bitcastFrom<int64_t>(currentSize)); - - guardArr.reset(); - return {ownAcc, tagAcc, valAcc}; -} - -std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggSetUnion(ArityType arity) { - auto [ownAcc, tagAcc, valAcc] = getFromStack(0); - - if (tagAcc == value::TypeTags::Nothing) { - // Initialize the accumulator. - ownAcc = true; - std::tie(tagAcc, valAcc) = value::makeNewArraySet(); - } else { - // Take ownership of the accumulator. - topStack(false, value::TypeTags::Nothing, 0); - } - - tassert(7039552, "accumulator must be owned", ownAcc); - value::ValueGuard guardAcc{tagAcc, valAcc}; - tassert(7039553, "accumulator must be of type ArraySet", tagAcc == value::TypeTags::ArraySet); - auto acc = value::getArraySetView(valAcc); - - auto [tagNewSet, valNewSet] = moveOwnedFromStack(1); - value::ValueGuard guardNewSet{tagNewSet, valNewSet}; - if (!value::isArray(tagNewSet)) { - return {false, value::TypeTags::Nothing, 0}; - } - - auto i = value::ArrayEnumerator{tagNewSet, valNewSet}; - while (!i.atEnd()) { - auto [elTag, elVal] = i.getViewOfValue(); - auto [copyTag, copyVal] = value::copyValue(elTag, elVal); - acc->push_back(copyTag, copyVal); - i.advance(); - } - - guardAcc.reset(); - return {ownAcc, tagAcc, valAcc}; -} - -std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggSetUnionCapped( - ArityType arity) { - auto [tagNewElem, valNewElem] = moveOwnedFromStack(1); - value::ValueGuard guardNewElem{tagNewElem, valNewElem}; - - auto [_, tagSizeCap, valSizeCap] = getFromStack(2); - tassert(7039509, - "'cap' parameter must be a 32-bit int", - tagSizeCap == value::TypeTags::NumberInt32); - const size_t sizeCap = value::bitcastTo<int32_t>(valSizeCap); - - guardNewElem.reset(); - return aggSetUnionCappedImpl(tagNewElem, valNewElem, sizeCap, nullptr /*collator*/); -} - -std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinAggCollSetUnionCapped( - ArityType arity) { - auto [_1, tagColl, valColl] = getFromStack(1); - auto [tagNewElem, valNewElem] = moveOwnedFromStack(2); - value::ValueGuard guardNewElem{tagNewElem, valNewElem}; - auto [_2, tagSizeCap, valSizeCap] = getFromStack(3); - - tassert(7039510, "expected value of type 'collator'", tagColl == value::TypeTags::collator); - tassert(7039511, - "'cap' parameter must be a 32-bit int", - tagSizeCap == value::TypeTags::NumberInt32); - - guardNewElem.reset(); - return aggSetUnionCappedImpl(tagNewElem, - valNewElem, - value::bitcastTo<int32_t>(valSizeCap), - value::getCollatorView(valColl)); -} - std::tuple<bool, value::TypeTags, value::Value> ByteCode::builtinCollSetIntersection( ArityType arity) { invariant(arity >= 1); @@ -4667,7 +4382,7 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::dispatchBuiltin(Builti case Builtin::doubleDoubleSum: return builtinDoubleDoubleSum(arity); case Builtin::aggDoubleDoubleSum: - return builtinAggDoubleDoubleSum<false /*merging*/>(arity); + return builtinAggDoubleDoubleSum(arity); case Builtin::doubleDoubleSumFinalize: return builtinDoubleDoubleSumFinalize<>(arity); case Builtin::doubleDoubleMergeSumFinalize: @@ -4676,12 +4391,8 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::dispatchBuiltin(Builti return builtinDoubleDoubleSumFinalize<true /*keepIntegerPrecision*/>(arity); case Builtin::doubleDoublePartialSumFinalize: return builtinDoubleDoublePartialSumFinalize(arity); - case Builtin::aggMergeDoubleDoubleSums: - return builtinAggDoubleDoubleSum<true /*merging*/>(arity); case Builtin::aggStdDev: - return builtinAggStdDev<false /*merging*/>(arity); - case Builtin::aggMergeStdDevs: - return builtinAggStdDev<true /*merging*/>(arity); + return builtinAggStdDev(arity); case Builtin::stdDevPopFinalize: return builtinStdDevPopFinalize(arity); case Builtin::stdDevSampFinalize: @@ -4734,16 +4445,6 @@ std::tuple<bool, value::TypeTags, value::Value> ByteCode::dispatchBuiltin(Builti return builtinRound(arity); case Builtin::concat: return builtinConcat(arity); - case Builtin::concatArrays: - return builtinConcatArrays(arity); - case Builtin::aggConcatArraysCapped: - return builtinAggConcatArraysCapped(arity); - case Builtin::aggSetUnion: - return builtinAggSetUnion(arity); - case Builtin::aggSetUnionCapped: - return builtinAggSetUnionCapped(arity); - case Builtin::aggCollSetUnionCapped: - return builtinAggCollSetUnionCapped(arity); case Builtin::isMember: return builtinIsMember(arity); case Builtin::collIsMember: diff --git a/src/mongo/db/exec/sbe/vm/vm.h b/src/mongo/db/exec/sbe/vm/vm.h index e5148e8d4b2..255a1a497c2 100644 --- a/src/mongo/db/exec/sbe/vm/vm.h +++ b/src/mongo/db/exec/sbe/vm/vm.h @@ -511,33 +511,12 @@ enum class Builtin : uint8_t { collAddToSet, // agg function to append to a set (with collation) collAddToSetCapped, // agg function to append to a set (with collation), fails when the set // reaches specified size - - // Special double summation. - doubleDoubleSum, - // A variant of the standard sum aggregate function which maintains a DoubleDouble as the - // accumulator's underlying state. + doubleDoubleSum, // special double summation aggDoubleDoubleSum, - // Converts a DoubleDouble sum into a single numeric scalar for use once the summation is - // complete. doubleDoubleSumFinalize, - // A form of doubleDoubleSum finalization only necessary for sharding support when the cluster - // is not yet fully upgraded to FCV 6.0. doubleDoubleMergeSumFinalize, - // Converts a partial sum into a format suitable for serialization over the wire to the merging - // node. The merging node expects the internal state of the DoubleDouble summation to be - // serialized in a particular format. doubleDoublePartialSumFinalize, - // An agg function which can be used to sum a sequence of DoubleDouble inputs, producing the - // resulting total as a DoubleDouble. - aggMergeDoubleDoubleSums, - - // Implements Welford's online algorithm for computing sample or population standard deviation - // in a single pass. aggStdDev, - // Combines standard deviations that have been partially computed on a subset of the data - // using Welford's online algorithm. - aggMergeStdDevs, - stdDevPopFinalize, stdDevSampFinalize, bitTestZero, // test bitwise mask & value is zero @@ -548,18 +527,6 @@ enum class Builtin : uint8_t { toLower, coerceToString, concat, - concatArrays, - - // Agg function to concatenate arrays, failing when the accumulator reaches a specified size. - aggConcatArraysCapped, - - // Agg functions to compute the set union of two arrays, failing when the accumulator reaches a - // specified size. - aggSetUnionCapped, - aggCollSetUnionCapped, - // Agg function for a simple set union (with no size cap or collation). - aggSetUnion, - acos, acosh, asin, @@ -1013,19 +980,11 @@ private: value::TypeTags fieldTag, value::Value fieldValue); - void aggDoubleDoubleSumImpl(value::Array* accumulator, - value::TypeTags rhsTag, - value::Value rhsValue); - void aggMergeDoubleDoubleSumsImpl(value::Array* accumulator, - value::TypeTags rhsTag, - value::Value rhsValue); + void aggDoubleDoubleSumImpl(value::Array* arr, value::TypeTags rhsTag, value::Value rhsValue); // This is an implementation of the following algorithm: // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm - void aggStdDevImpl(value::Array* accumulator, value::TypeTags rhsTag, value::Value rhsValue); - void aggMergeStdDevsImpl(value::Array* accumulator, - value::TypeTags rhsTag, - value::Value rhsValue); + void aggStdDevImpl(value::Array* arr, value::TypeTags rhsTag, value::Value rhsValue); std::tuple<bool, value::TypeTags, value::Value> aggStdDevFinalizeImpl(value::Value fieldValue, bool isSamp); @@ -1144,24 +1103,14 @@ private: CollatorInterface* collator); std::tuple<bool, value::TypeTags, value::Value> builtinAddToSetCapped(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinCollAddToSetCapped(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinDoubleDoubleSum(ArityType arity); - // The template parameter is false for a regular DoubleDouble summation and true if merging - // partially computed DoubleDouble sums. - template <bool merging> std::tuple<bool, value::TypeTags, value::Value> builtinAggDoubleDoubleSum(ArityType arity); - // This is only for compatibility with mongos/sharding and we will revisit this later. template <bool keepIntegerPrecision = false> std::tuple<bool, value::TypeTags, value::Value> builtinDoubleDoubleSumFinalize(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinDoubleDoublePartialSumFinalize( ArityType arity); - - // The template parameter is false for a regular std dev and true if merging partially computed - // standard devations. - template <bool merging> std::tuple<bool, value::TypeTags, value::Value> builtinAggStdDev(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinStdDevPopFinalize(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinStdDevSampFinalize(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinBitTestZero(ArityType arity); @@ -1188,16 +1137,6 @@ private: std::tuple<bool, value::TypeTags, value::Value> builtinTanh(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinRound(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinConcat(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinConcatArrays(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinAggConcatArraysCapped(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinAggSetUnion(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinAggSetUnionCapped(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> builtinAggCollSetUnionCapped(ArityType arity); - std::tuple<bool, value::TypeTags, value::Value> aggSetUnionCappedImpl( - value::TypeTags tagNewElem, - value::Value valNewElem, - int32_t sizeCap, - CollatorInterface* collator); std::tuple<bool, value::TypeTags, value::Value> builtinIsMember(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinCollIsMember(ArityType arity); std::tuple<bool, value::TypeTags, value::Value> builtinIndexOfBytes(ArityType arity); diff --git a/src/mongo/db/exec/scoped_timer.cpp b/src/mongo/db/exec/scoped_timer.cpp index bd53003faa5..f33c498a57a 100644 --- a/src/mongo/db/exec/scoped_timer.cpp +++ b/src/mongo/db/exec/scoped_timer.cpp @@ -32,8 +32,6 @@ #include "mongo/db/exec/scoped_timer.h" #include "mongo/util/clock_source.h" -#include "mongo/bson/bsonobjbuilder.h" - namespace mongo { ScopedTimer::ScopedTimer(ClockSource* cs, long long* counter) @@ -44,25 +42,4 @@ ScopedTimer::~ScopedTimer() { *_counter += elapsed; } - -TimeElapsedBuilderScopedTimer::TimeElapsedBuilderScopedTimer(ClockSource* clockSource, - StringData description, - BSONObjBuilder* builder) - : _clockSource(clockSource), - _description(description), - _beginTime(clockSource->now()), - _builder(builder) {} - -TimeElapsedBuilderScopedTimer::~TimeElapsedBuilderScopedTimer() { - mongo::Milliseconds elapsedTime = _clockSource->now() - _beginTime; - _builder->append(_description, elapsedTime.toString()); -} - -boost::optional<TimeElapsedBuilderScopedTimer> createTimeElapsedBuilderScopedTimer( - ClockSource* clockSource, StringData description, BSONObjBuilder* builder) { - if (builder == nullptr) { - return boost::none; - } - return TimeElapsedBuilderScopedTimer(clockSource, description, builder); -} } // namespace mongo diff --git a/src/mongo/db/exec/scoped_timer.h b/src/mongo/db/exec/scoped_timer.h index c3c52243369..c11c424e59a 100644 --- a/src/mongo/db/exec/scoped_timer.h +++ b/src/mongo/db/exec/scoped_timer.h @@ -59,28 +59,4 @@ private: const Date_t _start; }; -/** - * The timer appends the time elapsed since its construction to a BSON Object. - */ -class TimeElapsedBuilderScopedTimer { -public: - explicit TimeElapsedBuilderScopedTimer(ClockSource* clockSource, - StringData description, - BSONObjBuilder* builder); - ~TimeElapsedBuilderScopedTimer(); - -private: - ClockSource* _clockSource; - StringData _description; - Date_t _beginTime; - BSONObjBuilder* _builder; -}; - -/* - * This helper function only creates a TimeElapsedBuilderScopedTimer when a valid pointer to a - * builder is passed in. This is used when timing startup tasks, so that tasks that run during - * startup and outside of startup will only be timed when they are called during startup. - */ -boost::optional<TimeElapsedBuilderScopedTimer> createTimeElapsedBuilderScopedTimer( - ClockSource* clockSource, StringData description, BSONObjBuilder* builder); } // namespace mongo diff --git a/src/mongo/db/exec/skip.cpp b/src/mongo/db/exec/skip.cpp index 755e9278fe0..d3d0fc48afd 100644 --- a/src/mongo/db/exec/skip.cpp +++ b/src/mongo/db/exec/skip.cpp @@ -47,7 +47,7 @@ SkipStage::SkipStage(ExpressionContext* expCtx, long long toSkip, WorkingSet* ws, std::unique_ptr<PlanStage> child) - : PlanStage(kStageType, expCtx), _ws(ws), _leftToSkip(toSkip), _skipAmount(toSkip) { + : PlanStage(kStageType, expCtx), _ws(ws), _toSkip(toSkip) { _children.emplace_back(std::move(child)); } @@ -63,9 +63,9 @@ PlanStage::StageState SkipStage::doWork(WorkingSetID* out) { if (PlanStage::ADVANCED == status) { // If we're still skipping results... - if (_leftToSkip > 0) { + if (_toSkip > 0) { // ...drop the result. - --_leftToSkip; + --_toSkip; _ws->free(id); return PlanStage::NEED_TIME; } @@ -82,7 +82,7 @@ PlanStage::StageState SkipStage::doWork(WorkingSetID* out) { unique_ptr<PlanStageStats> SkipStage::getStats() { _commonStats.isEOF = isEOF(); - _specificStats.skip = _skipAmount; + _specificStats.skip = _toSkip; unique_ptr<PlanStageStats> ret = std::make_unique<PlanStageStats>(_commonStats, STAGE_SKIP); ret->specific = std::make_unique<SkipStats>(_specificStats); ret->children.emplace_back(child()->getStats()); diff --git a/src/mongo/db/exec/skip.h b/src/mongo/db/exec/skip.h index 5d0a764bd8a..24937662d02 100644 --- a/src/mongo/db/exec/skip.h +++ b/src/mongo/db/exec/skip.h @@ -66,13 +66,8 @@ public: private: WorkingSet* _ws; - // The number of results left to skip. This number is decremented during query execution as we - // successfully skip a document. - long long _leftToSkip; - - // Represents the number of results to skip. Unlike '_leftToSkip', this remains constant and - // is used when gathering statistics in explain. - const long long _skipAmount; + // We drop the first _toSkip results that we would have returned. + long long _toSkip; // Stats SkipStats _specificStats; diff --git a/src/mongo/db/exec/sort_executor.h b/src/mongo/db/exec/sort_executor.h index 8120f52caa9..6509c767e9a 100644 --- a/src/mongo/db/exec/sort_executor.h +++ b/src/mongo/db/exec/sort_executor.h @@ -139,7 +139,7 @@ public: } _output.reset(_sorter->done()); _stats.keysSorted += _sorter->numSorted(); - _stats.spills += _sorter->stats().spilledRanges(); + _stats.spills += _sorter->numSpills(); _stats.totalDataSizeBytes += _sorter->totalDataSizeSorted(); _sorter.reset(); } diff --git a/src/mongo/db/exec/stagedebug_cmd.cpp b/src/mongo/db/exec/stagedebug_cmd.cpp index a4548ce4a4c..d83af04df07 100644 --- a/src/mongo/db/exec/stagedebug_cmd.cpp +++ b/src/mongo/db/exec/stagedebug_cmd.cpp @@ -261,7 +261,7 @@ public: BSONObj keyPatternObj = keyPatternElement.Obj(); std::vector<const IndexDescriptor*> indexes; collection->getIndexCatalog()->findIndexesByKeyPattern( - opCtx, keyPatternObj, IndexCatalog::InclusionPolicy::kReady, &indexes); + opCtx, keyPatternObj, false, &indexes); uassert(16890, str::stream() << "Can't find index: " << keyPatternObj, !indexes.empty()); diff --git a/src/mongo/db/exec/text_or.cpp b/src/mongo/db/exec/text_or.cpp index f9e0745ca16..a0ba3eb347e 100644 --- a/src/mongo/db/exec/text_or.cpp +++ b/src/mongo/db/exec/text_or.cpp @@ -104,7 +104,9 @@ std::unique_ptr<PlanStageStats> TextOrStage::getStats() { _commonStats.isEOF = isEOF(); if (_filter) { - _commonStats.filter = _filter->serialize(); + BSONObjBuilder bob; + _filter->serialize(&bob); + _commonStats.filter = bob.obj(); } unique_ptr<PlanStageStats> ret = std::make_unique<PlanStageStats>(_commonStats, STAGE_TEXT_OR); diff --git a/src/mongo/db/exec/update_stage.cpp b/src/mongo/db/exec/update_stage.cpp index 32887ab1f19..5a273dc2d89 100644 --- a/src/mongo/db/exec/update_stage.cpp +++ b/src/mongo/db/exec/update_stage.cpp @@ -278,9 +278,6 @@ BSONObj UpdateStage::transformAndUpdate(const Snapshotted<BSONObj>& oldObj, // Ensure we set the type correctly args.source = writeToOrphan ? OperationSource::kFromMigrate : request->source(); - args.mustCheckExistenceForInsertOperations = - driver->getUpdateExecutor()->getCheckExistenceForDiffInsertOperations(); - if (inPlace) { if (!request->explain()) { newObj = oldObj.value(); @@ -462,41 +459,24 @@ PlanStage::StageState UpdateStage::doWork(WorkingSetID* out) { bool writeToOrphan = false; if (!_params.request->explain() && _isUserInitiatedWrite) { - try { - const auto action = _preWriteFilter.computeAction(member->doc.value()); - if (action == write_stage_common::PreWriteFilter::Action::kSkip) { - LOGV2_DEBUG( - 5983200, - 3, - "Skipping update operation to orphan document to prevent a wrong change " - "stream event", - "namespace"_attr = collection()->ns(), - "record"_attr = member->doc.value()); - return PlanStage::NEED_TIME; - } else if (action == - write_stage_common::PreWriteFilter::Action::kWriteAsFromMigrate) { - LOGV2_DEBUG( - 6184701, - 3, - "Marking update operation to orphan document with the fromMigrate flag " - "to prevent a wrong change stream event", - "namespace"_attr = collection()->ns(), - "record"_attr = member->doc.value()); - writeToOrphan = true; - } - } catch (const ExceptionFor<ErrorCodes::StaleConfig>& ex) { - if (ex->getVersionReceived() == ChunkVersion::IGNORED() && - ex->getCriticalSectionSignal()) { - // If ChunkVersion is IGNORED and we encountered a critical section, then yield, - // wait for critical section to finish and then we'll resume the write from the - // point we had left. We do this to prevent large multi-writes from repeatedly - // failing due to StaleConfig and exhausting the mongos retry attempts. - planExecutorShardingCriticalSectionFuture(opCtx()) = - ex->getCriticalSectionSignal(); - memberFreer.dismiss(); // Keep this member around so we can retry deleting it. - return prepareToRetryWSM(id, out); - } - throw; + const auto action = _preWriteFilter.computeAction(member->doc.value()); + if (action == write_stage_common::PreWriteFilter::Action::kSkip) { + LOGV2_DEBUG( + 5983200, + 3, + "Skipping update operation to orphan document to prevent a wrong change " + "stream event", + "namespace"_attr = collection()->ns(), + "record"_attr = member->doc.value()); + return PlanStage::NEED_TIME; + } else if (action == write_stage_common::PreWriteFilter::Action::kWriteAsFromMigrate) { + LOGV2_DEBUG(6184701, + 3, + "Marking update operation to orphan document with the fromMigrate flag " + "to prevent a wrong change stream event", + "namespace"_attr = collection()->ns(), + "record"_attr = member->doc.value()); + writeToOrphan = true; } } @@ -526,18 +506,6 @@ PlanStage::StageState UpdateStage::doWork(WorkingSetID* out) { } catch (const WriteConflictException&) { memberFreer.dismiss(); // Keep this member around so we can retry updating it. return prepareToRetryWSM(id, out); - } catch (const ExceptionFor<ErrorCodes::StaleConfig>& ex) { - if (ex->getVersionReceived() == ChunkVersion::IGNORED() && - ex->getCriticalSectionSignal()) { - // If ChunkVersion is IGNORED and we encountered a critical section, then yield, - // wait for critical section to finish and then we'll resume the write from the - // point we had left. We do this to prevent large multi-writes from repeatedly - // failing due to StaleConfig and exhausting the mongos retry attempts. - planExecutorShardingCriticalSectionFuture(opCtx()) = ex->getCriticalSectionSignal(); - memberFreer.dismiss(); // Keep this member around so we can retry updating it. - return prepareToRetryWSM(id, out); - } - throw; } // Set member's obj to be the doc we want to return. diff --git a/src/mongo/db/exec/upsert_stage.cpp b/src/mongo/db/exec/upsert_stage.cpp index dfb54a99082..423e300fcf7 100644 --- a/src/mongo/db/exec/upsert_stage.cpp +++ b/src/mongo/db/exec/upsert_stage.cpp @@ -31,7 +31,7 @@ #include "mongo/db/catalog/document_validation.h" #include "mongo/db/catalog/local_oplog_info.h" -#include "mongo/db/concurrency/exception_util.h" +#include "mongo/db/concurrency/write_conflict_exception.h" #include "mongo/db/curop_failpoint_helpers.h" #include "mongo/db/query/query_feature_flags_gen.h" #include "mongo/db/s/collection_sharding_state.h" @@ -273,13 +273,8 @@ void UpsertStage::_generateNewDocumentFromSuppliedDoc(const FieldRefSet& immutab UpdateDriver replacementDriver(nullptr); // Create a new replacement-style update from the supplied document. - replacementDriver.parse( - write_ops::UpdateModification( - suppliedDoc, write_ops::UpdateModification::ClassicTag{}, true /* isReplacement */), - {}); + replacementDriver.parse(write_ops::UpdateModification::parseFromClassicUpdate(suppliedDoc), {}); replacementDriver.setLogOp(false); - replacementDriver.setBypassEmptyTsReplacement( - static_cast<bool>(_params.request->getBypassEmptyTsReplacement())); // We do not validate for storage, as we will validate the full document before inserting. // However, we ensure that no immutable fields are modified. diff --git a/src/mongo/db/exec/working_set_common.cpp b/src/mongo/db/exec/working_set_common.cpp index 3920e6ad79a..1a1a04cade6 100644 --- a/src/mongo/db/exec/working_set_common.cpp +++ b/src/mongo/db/exec/working_set_common.cpp @@ -37,8 +37,6 @@ #include "mongo/bson/simple_bsonobj_comparator.h" #include "mongo/db/catalog/collection.h" -#include "mongo/db/catalog/health_log_gen.h" -#include "mongo/db/catalog/health_log_interface.h" #include "mongo/db/exec/working_set.h" #include "mongo/db/index/index_access_method.h" #include "mongo/db/query/canonical_query.h" @@ -46,7 +44,6 @@ #include "mongo/db/storage/execution_context.h" #include "mongo/db/storage/index_entry_comparison.h" #include "mongo/logv2/log.h" -#include "mongo/util/stacktrace.h" namespace mongo { @@ -109,30 +106,6 @@ bool WorkingSetCommon::fetch(OperationContext* opCtx, builder.append("pattern"_sd, ikd.indexKeyPattern); return builder.obj(); }; - - HealthLogEntry entry; - entry.setNss(ns); - entry.setTimestamp(Date_t::now()); - entry.setSeverity(SeverityEnum::Error); - entry.setScope(ScopeEnum::Index); - entry.setOperation("Index scan"); - entry.setMsg("Erroneous index key found with reference to non-existent record id"); - - BSONObjBuilder bob; - bob.append("recordId", member->recordId.toString()); - - const BSONArray indexKeyData = - logv2::seqLog( - boost::make_transform_iterator(member->keyData.begin(), indexKeyEntryToObjFn), - boost::make_transform_iterator(member->keyData.end(), indexKeyEntryToObjFn)) - .toBSONArray(); - bob.append("indexKeyData", indexKeyData); - - bob.appendElements(getStackTrace().getBSONRepresentation()); - entry.setData(bob.obj()); - - HealthLogInterface::get(opCtx)->log(entry); - LOGV2_ERROR_OPTIONS( 4615603, {logv2::UserAssertAfterLog(ErrorCodes::DataCorruptionDetected)}, @@ -141,7 +114,9 @@ bool WorkingSetCommon::fetch(OperationContext* opCtx, "on the collection.", "namespace"_attr = ns, "recordId"_attr = member->recordId, - "indexKeyData"_attr = indexKeyData); + "indexKeyData"_attr = logv2::seqLog( + boost::make_transform_iterator(member->keyData.begin(), indexKeyEntryToObjFn), + boost::make_transform_iterator(member->keyData.end(), indexKeyEntryToObjFn))); } return false; } diff --git a/src/mongo/db/exec/write_stage_common.cpp b/src/mongo/db/exec/write_stage_common.cpp index b0a8db18564..9b8aeb371e3 100644 --- a/src/mongo/db/exec/write_stage_common.cpp +++ b/src/mongo/db/exec/write_stage_common.cpp @@ -31,6 +31,7 @@ #include "mongo/db/exec/write_stage_common.h" #include "mongo/db/catalog/collection.h" +#include "mongo/db/concurrency/write_conflict_exception.h" #include "mongo/db/exec/shard_filterer_impl.h" #include "mongo/db/exec/working_set.h" #include "mongo/db/exec/working_set_common.h" @@ -55,15 +56,14 @@ PreWriteFilter::PreWriteFilter(OperationContext* opCtx, NamespaceString nss) feature_flags::gFeatureFlagNoChangeStreamEventsDueToOrphans.isEnabled(fcv); }()), _skipFiltering([&] { - // Allow writes on standalone and replica set. + // Always allow writes on replica sets. if (serverGlobalParams.clusterRole == ClusterRole::None) { return true; } - // Only the primary node of a shard that is a replica set should run this filter. - const auto replCoord = repl::ReplicationCoordinator::get(opCtx); - return !replCoord->getSettings().usingReplSets() || - !replCoord->canAcceptWritesForDatabase(opCtx, NamespaceString::kAdminDb); + // Always allow writes on standalone and secondary nodes. + const auto replCoord{repl::ReplicationCoordinator::get(opCtx)}; + return !replCoord->canAcceptWritesForDatabase(opCtx, NamespaceString::kAdminDb); }()) {} PreWriteFilter::Action PreWriteFilter::computeAction(const Document& doc) { diff --git a/src/mongo/db/exec/write_stage_common.h b/src/mongo/db/exec/write_stage_common.h index 489afa62f2f..5628822efff 100644 --- a/src/mongo/db/exec/write_stage_common.h +++ b/src/mongo/db/exec/write_stage_common.h @@ -29,6 +29,8 @@ #pragma once +#include "mongo/platform/basic.h" + #include "mongo/db/exec/shard_filterer.h" #include "mongo/db/exec/working_set.h" #include "mongo/db/namespace_string.h" |