diff options
Diffstat (limited to 'src/mongo/db/query')
177 files changed, 1947 insertions, 15801 deletions
diff --git a/src/mongo/db/query/SConscript b/src/mongo/db/query/SConscript index d6da5af72e4..025fd11d118 100644 --- a/src/mongo/db/query/SConscript +++ b/src/mongo/db/query/SConscript @@ -1,9 +1,6 @@ # -*- mode: python -*- -Import([ - "env", - "get_option", -]) +Import("env") env = env.Clone() @@ -13,8 +10,6 @@ env.SConscript( "collation", "datetime", 'optimizer', - 'query_stats', - 'query_shape', ], exports=[ 'env' @@ -24,11 +19,8 @@ env.SConscript( env.Library( target='canonical_query', source=[ - 'canonical_query.cpp', - 'canonical_query_encoder.cpp', - 'parsed_find_command.cpp', - 'query_shape/find_cmd_shape.cpp', - 'query_stats/find_key.cpp', + "canonical_query.cpp", + "canonical_query_encoder.cpp", ], LIBDEPS=[ "$BUILD_DIR/mongo/crypto/encrypted_field_config", @@ -61,7 +53,6 @@ env.Library( "query_planner.cpp", "query_settings.cpp", "query_solution.cpp", - "record_id_range.cpp", "stage_types.cpp", ], LIBDEPS=[ @@ -70,6 +61,7 @@ env.Library( "$BUILD_DIR/mongo/db/commands/server_status_core", "$BUILD_DIR/mongo/db/exec/sbe/query_sbe_plan_stats", "$BUILD_DIR/mongo/db/index/expression_params", + "$BUILD_DIR/mongo/db/index/key_generator", "$BUILD_DIR/mongo/db/index_names", "canonical_query", "query_index_bounds", @@ -78,7 +70,6 @@ env.Library( ], LIBDEPS_PRIVATE=[ '$BUILD_DIR/mongo/db/fts/base_fts', - '$BUILD_DIR/mongo/db/index/index_access_method', "$BUILD_DIR/mongo/db/record_id_helpers", "$BUILD_DIR/mongo/idl/server_parameter", ], @@ -99,17 +90,6 @@ env.Library( ) env.Library( - target='memory_util', - source=[ - 'util/memory_util.cpp', - ], - LIBDEPS=[ - '$BUILD_DIR/mongo/util/processinfo', - '$BUILD_DIR/mongo/util/regex_util', - ], -) - -env.Library( target="query_plan_cache", source=[ "classic_plan_cache.cpp", @@ -121,7 +101,6 @@ env.Library( "$BUILD_DIR/mongo/base", "$BUILD_DIR/mongo/db/exec/sbe/query_sbe", "canonical_query", - "memory_util", ] ) @@ -139,9 +118,6 @@ env.Library( "$BUILD_DIR/mongo/db/matcher/expressions", "$BUILD_DIR/mongo/db/storage/execution_context", ], - LIBDEPS_PRIVATE=[ - '$BUILD_DIR/mongo/db/catalog/health_log_interface', - ], ) env.Library( @@ -282,18 +258,17 @@ env.Library( env.Library( target="query_knobs", source=[ + 'plan_cache_size_parameter.cpp', 'query_feature_flags.idl', 'query_knobs.idl', - 'query_stats/query_stats_on_parameter_change.cpp', 'sbe_plan_cache_on_parameter_change.cpp', ], LIBDEPS_PRIVATE=[ - '$BUILD_DIR/mongo/db/service_context', + "$BUILD_DIR/mongo/db/service_context", '$BUILD_DIR/mongo/idl/feature_flag', '$BUILD_DIR/mongo/idl/server_parameter', '$BUILD_DIR/third_party/shim_pcrecpp', - 'memory_util', - ], + ] ) env.Library( @@ -367,10 +342,10 @@ env.Library( '$BUILD_DIR/mongo/util/fail_point', ], LIBDEPS_PRIVATE=[ - '$BUILD_DIR/mongo/db/concurrency/exception_util', + '$BUILD_DIR/mongo/db/concurrency/write_conflict_exception', '$BUILD_DIR/mongo/db/storage/recovery_unit_base', ], -) + ) env.CppUnitTest( target="db_query_test", @@ -381,7 +356,6 @@ env.CppUnitTest( "classic_stage_builder_test.cpp", "count_command_test.cpp", "cursor_response_test.cpp", - "find_common_test.cpp", "get_executor_test.cpp", "getmore_request_test.cpp", "hint_parser_test.cpp", @@ -397,12 +371,13 @@ env.CppUnitTest( "interval_test.cpp", "killcursors_request_test.cpp", "lru_key_value_test.cpp", + 'map_reduce_output_format_test.cpp', "parsed_distinct_test.cpp", "plan_cache_indexability_test.cpp", + "plan_cache_size_parameter_test.cpp", "plan_cache_key_info_test.cpp", "plan_cache_test.cpp", "plan_ranker_test.cpp", - "plan_ranker_index_prefix_test.cpp", "planner_access_test.cpp", "planner_analysis_test.cpp", "planner_ixselect_test.cpp", @@ -412,52 +387,41 @@ env.CppUnitTest( "query_planner_collation_test.cpp", "query_planner_columnar_test.cpp", "query_planner_geo_test.cpp", + "query_planner_pipeline_pushdown_test.cpp", "query_planner_hashed_index_test.cpp", + "query_planner_partialidx_test.cpp", "query_planner_index_test.cpp", "query_planner_operator_test.cpp", "query_planner_options_test.cpp", - "query_planner_partialidx_test.cpp", - "query_planner_pipeline_pushdown_test.cpp", - "query_planner_text_test.cpp", "query_planner_tree_test.cpp", + "query_planner_text_test.cpp", "query_planner_wildcard_index_test.cpp", "query_request_test.cpp", "query_settings_test.cpp", - 'query_shape/agg_cmd_shape_test.cpp', - 'query_shape/cmd_with_let_shape_test.cpp', - "query_shape/find_cmd_shape_test.cpp", "query_solution_test.cpp", - "record_id_range_test.cpp", "sbe_and_hash_test.cpp", "sbe_and_sorted_test.cpp", - "sbe_shard_filter_test.cpp", "sbe_stage_builder_accumulator_test.cpp", "sbe_stage_builder_lookup_test.cpp", - "sbe_stage_builder_test.cpp", "sbe_stage_builder_test_fixture.cpp", + "sbe_stage_builder_test.cpp", + "sbe_shard_filter_test.cpp", "shard_filterer_factory_mock.cpp", - "sort_pattern_test.cpp", - "util/deferred_test.cpp", - "util/memory_util_test.cpp", "view_response_formatter_test.cpp", - 'map_reduce_output_format_test.cpp', ], LIBDEPS=[ "$BUILD_DIR/mongo/db/auth/authmocks", "$BUILD_DIR/mongo/db/concurrency/lock_manager", - "$BUILD_DIR/mongo/db/exec/document_value/document_value_test_util", "$BUILD_DIR/mongo/db/exec/sbe/sbe_plan_stage_test", "$BUILD_DIR/mongo/db/multitenancy", "$BUILD_DIR/mongo/db/pipeline/aggregation_request_helper", "$BUILD_DIR/mongo/db/pipeline/document_source_mock", "$BUILD_DIR/mongo/db/query_exec", - '$BUILD_DIR/mongo/db/record_id_helpers', "$BUILD_DIR/mongo/db/repl/replmocks", "$BUILD_DIR/mongo/db/repl/storage_interface_impl", "$BUILD_DIR/mongo/db/service_context_d_test_fixture", "$BUILD_DIR/mongo/db/service_context_test_fixture", "$BUILD_DIR/mongo/dbtests/mocklib", - "$BUILD_DIR/mongo/idl/idl_parser", "$BUILD_DIR/mongo/rpc/rpc", "$BUILD_DIR/mongo/util/clock_source_mock", "collation/collator_factory_mock", @@ -469,7 +433,6 @@ env.CppUnitTest( "query_planner", "query_planner_test_fixture", "query_request", - "query_shape/query_shape", "query_test_service_context", ], ) diff --git a/src/mongo/db/query/canonical_query.cpp b/src/mongo/db/query/canonical_query.cpp index 32ebde51cfb..865cd10b245 100644 --- a/src/mongo/db/query/canonical_query.cpp +++ b/src/mongo/db/query/canonical_query.cpp @@ -36,6 +36,7 @@ #include "mongo/crypto/encryption_fields_gen.h" #include "mongo/db/catalog/collection.h" #include "mongo/db/commands/test_commands_enabled.h" +#include "mongo/db/cst/cst_parser.h" #include "mongo/db/jsobj.h" #include "mongo/db/matcher/expression_array.h" #include "mongo/db/namespace_string.h" @@ -44,158 +45,162 @@ #include "mongo/db/query/collation/collator_factory_interface.h" #include "mongo/db/query/fle/server_rewrite.h" #include "mongo/db/query/indexability.h" -#include "mongo/db/query/parsed_find_command.h" #include "mongo/db/query/projection_parser.h" #include "mongo/db/query/query_planner_common.h" #include "mongo/logv2/log.h" namespace mongo { +namespace { + +bool parsingCanProduceNoopMatchNodes(const ExtensionsCallback& extensionsCallback, + MatchExpressionParser::AllowedFeatureSet allowedFeatures) { + return extensionsCallback.hasNoopExtensions() && + (allowedFeatures & MatchExpressionParser::AllowedFeatures::kText || + allowedFeatures & MatchExpressionParser::AllowedFeatures::kJavascript); +} + +} // namespace // static StatusWith<std::unique_ptr<CanonicalQuery>> CanonicalQuery::canonicalize( OperationContext* opCtx, std::unique_ptr<FindCommandRequest> findCommand, bool explain, - const boost::intrusive_ptr<ExpressionContext>& givenExpCtx, + const boost::intrusive_ptr<ExpressionContext>& expCtx, const ExtensionsCallback& extensionsCallback, MatchExpressionParser::AllowedFeatureSet allowedFeatures, const ProjectionPolicies& projectionPolicies, std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline) { + tassert(5746107, + "ntoreturn should not be set on the findCommand", + findCommand->getNtoreturn() == boost::none); - if (givenExpCtx) { - // Caller provided an ExpressionContext, let's go ahead and use that. - auto swParsedFind = parsed_find_command::parse(givenExpCtx, - std::move(findCommand), - extensionsCallback, - allowedFeatures, - projectionPolicies); - if (!swParsedFind.isOK()) { - return swParsedFind.getStatus(); + auto status = query_request_helper::validateFindCommandRequest(*findCommand); + if (!status.isOK()) { + return status; + } + + std::unique_ptr<CollatorInterface> collator; + if (!findCommand->getCollation().isEmpty()) { + auto statusWithCollator = CollatorFactoryInterface::get(opCtx->getServiceContext()) + ->makeFromBSON(findCommand->getCollation()); + if (!statusWithCollator.isOK()) { + return statusWithCollator.getStatus(); } - return canonicalize(std::move(givenExpCtx), - std::move(swParsedFind.getValue()), - explain, - std::move(pipeline)); + collator = std::move(statusWithCollator.getValue()); + } + + // Make MatchExpression. + boost::intrusive_ptr<ExpressionContext> newExpCtx; + if (!expCtx.get()) { + invariant(findCommand->getNamespaceOrUUID().nss()); + newExpCtx = make_intrusive<ExpressionContext>(opCtx, + std::move(collator), + *findCommand->getNamespaceOrUUID().nss(), + findCommand->getLegacyRuntimeConstants(), + findCommand->getLet()); } else { - // No ExpressionContext provided, let's call the override that makes one for us. - auto swResults = parsed_find_command::parse( - opCtx, std::move(findCommand), extensionsCallback, allowedFeatures, projectionPolicies); - if (!swResults.isOK()) { - return swResults.getStatus(); + newExpCtx = expCtx; + // A collator can enter through both the FindCommandRequest and ExpressionContext arguments. + // This invariant ensures that both collators are the same because downstream we + // pull the collator from only one of the ExpressionContext carrier. + if (collator.get() && expCtx->getCollator()) { + invariant(CollatorInterface::collatorsMatch(collator.get(), expCtx->getCollator())); } - auto&& [expCtx, parsedFind] = std::move(swResults.getValue()); - return canonicalize(std::move(expCtx), std::move(parsedFind), explain, std::move(pipeline)); } -} - -// static -StatusWith<std::unique_ptr<CanonicalQuery>> CanonicalQuery::canonicalize( - boost::intrusive_ptr<ExpressionContext> expCtx, - std::unique_ptr<ParsedFindCommand> parsedFind, - bool explain, - std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline) { // Make the CQ we'll hopefully return. - auto cq = std::make_unique<CanonicalQuery>(); + std::unique_ptr<CanonicalQuery> cq(new CanonicalQuery()); cq->setExplain(explain); - if (auto initStatus = cq->init(std::move(expCtx), - std::move(parsedFind), - std::move(pipeline), - true /*optimizeMatchExpression*/); - !initStatus.isOK()) { + + StatusWithMatchExpression statusWithMatcher = [&]() -> StatusWithMatchExpression { + if (getTestCommandsEnabled() && internalQueryEnableCSTParser.load()) { + try { + return cst::parseToMatchExpression( + findCommand->getFilter(), newExpCtx, extensionsCallback); + } catch (const DBException& ex) { + return ex.toStatus(); + } + } else { + return MatchExpressionParser::parse( + findCommand->getFilter(), newExpCtx, extensionsCallback, allowedFeatures); + } + }(); + if (!statusWithMatcher.isOK()) { + return statusWithMatcher.getStatus(); + } + + // Stop counting expressions after they have been parsed to exclude expressions created + // during optimization and other processing steps. + newExpCtx->stopExpressionCounters(); + + std::unique_ptr<MatchExpression> me = std::move(statusWithMatcher.getValue()); + + Status initStatus = + cq->init(opCtx, + std::move(newExpCtx), + std::move(findCommand), + parsingCanProduceNoopMatchNodes(extensionsCallback, allowedFeatures), + std::move(me), + projectionPolicies, + std::move(pipeline)); + + if (!initStatus.isOK()) { return initStatus; } - return {std::move(cq)}; + return std::move(cq); } // static -StatusWith<std::unique_ptr<CanonicalQuery>> CanonicalQuery::makeForSubplanner( - OperationContext* opCtx, const CanonicalQuery& baseQuery, size_t i) { - tassert(8401301, - "expected MatchExpression with rooted $or", - baseQuery.root()->matchType() == MatchExpression::OR); - tassert(8401302, - "attempted to get out of bounds child of $or", - baseQuery.root()->numChildren() > i); - auto root = baseQuery.root()->getChild(i); +StatusWith<std::unique_ptr<CanonicalQuery>> CanonicalQuery::canonicalize( + OperationContext* opCtx, const CanonicalQuery& baseQuery, MatchExpression* root) { auto findCommand = std::make_unique<FindCommandRequest>(baseQuery.nss()); - findCommand->setFilter(root->serialize()); + BSONObjBuilder builder; + root->serialize(&builder, true); + findCommand->setFilter(builder.obj()); findCommand->setProjection(baseQuery.getFindCommandRequest().getProjection().getOwned()); findCommand->setSort(baseQuery.getFindCommandRequest().getSort().getOwned()); findCommand->setCollation(baseQuery.getFindCommandRequest().getCollation().getOwned()); + auto status = query_request_helper::validateFindCommandRequest(*findCommand); + if (!status.isOK()) { + return status; + } // Make the CQ we'll hopefully return. - auto cq = std::make_unique<CanonicalQuery>(); + std::unique_ptr<CanonicalQuery> cq(new CanonicalQuery()); cq->setExplain(baseQuery.getExplain()); - auto swParsedFind = ParsedFindCommand::withExistingFilter( - baseQuery.getExpCtx(), - baseQuery.getCollator() ? baseQuery.getCollator()->clone() : nullptr, - root->shallowClone(), - std::move(findCommand)); - if (!swParsedFind.isOK()) { - return swParsedFind.getStatus(); - } - // Note: we do not optimize the MatchExpression representing the branch of the top-level $or - // that we are currently examining. This is because repeated invocations of - // MatchExpression::optimize() may change the order of predicates in the MatchExpression, due to - // new rewrites being unlocked by previous ones. We need to preserve the order of predicates to - // allow index tagging to work properly. See SERVER-84013 for more details. - Status initStatus = cq->init(baseQuery.getExpCtx(), - std::move(swParsedFind.getValue()), - {} /* an empty pipeline */, - false /*optimizeMatchExpression*/); - - invariant(initStatus.isOK()); - return {std::move(cq)}; + Status initStatus = cq->init(opCtx, + baseQuery.getExpCtx(), + std::move(findCommand), + baseQuery.canHaveNoopMatchNodes(), + root->shallowClone(), + ProjectionPolicies::findProjectionPolicies(), + {} /* an empty pipeline */); + + if (!initStatus.isOK()) { + return initStatus; + } + return std::move(cq); } -Status CanonicalQuery::init(boost::intrusive_ptr<ExpressionContext> expCtx, - std::unique_ptr<ParsedFindCommand> parsedFind, - std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline, - bool optimizeMatchExpression) { +Status CanonicalQuery::init(OperationContext* opCtx, + boost::intrusive_ptr<ExpressionContext> expCtx, + std::unique_ptr<FindCommandRequest> findCommand, + bool canHaveNoopMatchNodes, + std::unique_ptr<MatchExpression> root, + const ProjectionPolicies& projectionPolicies, + std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline) { _expCtx = expCtx; - _findCommand = std::move(parsedFind->findCommandRequest); - _canHaveNoopMatchNodes = parsedFind->canHaveNoopMatchNodes; + _findCommand = std::move(findCommand); + _canHaveNoopMatchNodes = canHaveNoopMatchNodes; _forceClassicEngine = internalQueryForceClassicEngine.load(); - if (optimizeMatchExpression) { - _root = MatchExpression::normalize(std::move(parsedFind->filter)); - } else { - _root = std::move(parsedFind->filter); - } - - if (parsedFind->proj) { - // The projection will be optimized only if the query is not compatible with SBE or there's - // no user-specified "let" variable. This is to prevent the user-defined variable being - // optimized out. We will optimize the projection later after we are certain that the query - // is ineligible for SBE. - bool shouldOptimizeProj = !expCtx->sbeCompatible || !_findCommand->getLet(); - if (parsedFind->proj->requiresMatchDetails()) { - // Sadly, in some cases the match details cannot be generated from the unoptimized - // MatchExpression. For example, a rooted-$or of equalities won't work to produce the - // details, but if you optimize that query to an $in, it will work. If we were starting - // from scratch, we may disallow this. But it has already been released as working so we - // will keep it so, and here have to re-parse the projection using the new, normalized - // MatchExpression, before we save this projection for later execution. - _proj.emplace(projection_ast::parseAndAnalyze(expCtx, - _findCommand->getProjection(), - _root.get(), - _findCommand->getFilter(), - *parsedFind->savedProjectionPolicies, - shouldOptimizeProj)); - } else { - _proj.emplace(std::move(*parsedFind->proj)); - if (shouldOptimizeProj) { - _proj->optimize(); - } - } - } - if (parsedFind->sort) { - _sortPattern = std::move(parsedFind->sort); + auto validStatus = isValid(root.get(), *_findCommand); + if (!validStatus.isOK()) { + return validStatus.getStatus(); } - _pipeline = std::move(pipeline); - - // Perform auto-parameterization only if the query is SBE-compatible and caching is enabled. + auto unavailableMetadata = validStatus.getValue(); + _root = MatchExpression::normalize(std::move(root)); if (feature_flags::gFeatureFlagSbePlanCache.isEnabledAndIgnoreFCV()) { const bool hasNoTextNodes = !QueryPlannerCommon::hasNode(_root.get(), MatchExpression::TEXT); @@ -212,45 +217,89 @@ Status CanonicalQuery::init(boost::intrusive_ptr<ExpressionContext> expCtx, } } // The tree must always be valid after normalization. - dassert(parsed_find_command::isValid(_root.get(), *_findCommand).isOK()); + dassert(isValid(_root.get(), *_findCommand).isOK()); if (auto status = isValidNormalized(_root.get()); !status.isOK()) { return status; } - if (_proj) { - _metadataDeps = _proj->metadataDeps(); + // Validate the projection if there is one. + if (!_findCommand->getProjection().isEmpty()) { + try { + _proj.emplace(projection_ast::parseAndAnalyze(expCtx, + _findCommand->getProjection(), + _root.get(), + _findCommand->getFilter(), + projectionPolicies, + true /* Should optimize? */)); - if (_proj->metadataDeps()[DocumentMetadataFields::kSortKey] && - _findCommand->getSort().isEmpty()) { - return {ErrorCodes::BadValue, "cannot use sortKey $meta projection without a sort"}; + // Fail if any of the projection's dependencies are unavailable. + DepsTracker{unavailableMetadata}.requestMetadata(_proj->metadataDeps()); + } catch (const DBException& e) { + return e.toStatus(); } + + _metadataDeps = _proj->metadataDeps(); } - if (_sortPattern) { - // Be sure to track and add any metadata dependencies from the sort (e.g. text score). - _metadataDeps |= _sortPattern->metadataDeps(parsedFind->unavailableMetadata); + _pipeline = std::move(pipeline); - // If the results of this query might have to be merged on a remote node, then that node - // might need the sort key metadata. Request that the plan generates this metadata. - if (_expCtx->needsMerge) { - _metadataDeps.set(DocumentMetadataFields::kSortKey); - } + if (_proj && _proj->metadataDeps()[DocumentMetadataFields::kSortKey] && + _findCommand->getSort().isEmpty()) { + return Status(ErrorCodes::BadValue, "cannot use sortKey $meta projection without a sort"); + } + + // If there is a sort, parse it and add any metadata dependencies it induces. + try { + initSortPattern(unavailableMetadata); + } catch (const DBException& ex) { + return ex.toStatus(); } // If the 'returnKey' option is set, then the plan should produce index key metadata. if (_findCommand->getReturnKey()) { _metadataDeps.set(DocumentMetadataFields::kIndexKey); } + return Status::OK(); } +void CanonicalQuery::initSortPattern(QueryMetadataBitSet unavailableMetadata) { + if (_findCommand->getSort().isEmpty()) { + return; + } + + // A $natural sort is really a hint, and should be handled as such. Furthermore, the downstream + // sort handling code may not expect a $natural sort. + // + // We have already validated that if there is a $natural sort and a hint, that the hint + // also specifies $natural with the same direction. Therefore, it is safe to clear the $natural + // sort and rewrite it as a $natural hint. + if (_findCommand->getSort()[query_request_helper::kNaturalSortField]) { + _findCommand->setHint(_findCommand->getSort().getOwned()); + _findCommand->setSort(BSONObj{}); + } + + if (getTestCommandsEnabled() && internalQueryEnableCSTParser.load()) { + _sortPattern = cst::parseToSortPattern(_findCommand->getSort(), _expCtx); + } else { + _sortPattern = SortPattern{_findCommand->getSort(), _expCtx}; + } + _metadataDeps |= _sortPattern->metadataDeps(unavailableMetadata); + + // If the results of this query might have to be merged on a remote node, then that node might + // need the sort key metadata. Request that the plan generates this metadata. + if (_expCtx->needsMerge) { + _metadataDeps.set(DocumentMetadataFields::kSortKey); + } +} + void CanonicalQuery::setCollator(std::unique_ptr<CollatorInterface> collator) { auto collatorRaw = collator.get(); // We must give the ExpressionContext the same collator. _expCtx->setCollator(std::move(collator)); - // The collator associated with the match expression tree is now invalid, since we have - // reset the collator owned by the ExpressionContext. + // The collator associated with the match expression tree is now invalid, since we have reset + // the collator owned by the ExpressionContext. _root->setCollator(collatorRaw); } @@ -284,9 +333,138 @@ bool CanonicalQuery::isSimpleIdQuery(const BSONObj& query) { return hasID; } +size_t CanonicalQuery::countNodes(const MatchExpression* root, MatchExpression::MatchType type) { + size_t sum = 0; + if (type == root->matchType()) { + sum = 1; + } + for (size_t i = 0; i < root->numChildren(); ++i) { + sum += countNodes(root->getChild(i), type); + } + return sum; +} + +/** + * Does 'root' have a subtree of type 'subtreeType' with a node of type 'childType' inside? + */ +bool hasNodeInSubtree(const MatchExpression* root, + MatchExpression::MatchType childType, + MatchExpression::MatchType subtreeType) { + if (subtreeType == root->matchType()) { + return QueryPlannerCommon::hasNode(root, childType); + } + for (size_t i = 0; i < root->numChildren(); ++i) { + if (hasNodeInSubtree(root->getChild(i), childType, subtreeType)) { + return true; + } + } + return false; +} + +StatusWith<QueryMetadataBitSet> CanonicalQuery::isValid(const MatchExpression* root, + const FindCommandRequest& findCommand) { + QueryMetadataBitSet unavailableMetadata{}; + + // There can only be one TEXT. If there is a TEXT, it cannot appear inside a NOR. + // + // Note that the query grammar (as enforced by the MatchExpression parser) forbids TEXT + // inside of value-expression clauses like NOT, so we don't check those here. + size_t numText = countNodes(root, MatchExpression::TEXT); + if (numText > 1) { + return Status(ErrorCodes::BadValue, "Too many text expressions"); + } else if (1 == numText) { + if (hasNodeInSubtree(root, MatchExpression::TEXT, MatchExpression::NOR)) { + return Status(ErrorCodes::BadValue, "text expression not allowed in nor"); + } + } else { + // Text metadata is not available. + unavailableMetadata.set(DocumentMetadataFields::kTextScore); + } + + // There can only be one NEAR. If there is a NEAR, it must be either the root or the root + // must be an AND and its child must be a NEAR. + size_t numGeoNear = countNodes(root, MatchExpression::GEO_NEAR); + if (numGeoNear > 1) { + return Status(ErrorCodes::BadValue, "Too many geoNear expressions"); + } else if (1 == numGeoNear) { + // Do nothing, we will perform extra checks in CanonicalQuery::isValidNormalized. + } else { + // Geo distance and geo point metadata are unavailable. + unavailableMetadata |= DepsTracker::kAllGeoNearData; + } + + const BSONObj& sortObj = findCommand.getSort(); + BSONElement sortNaturalElt = sortObj["$natural"]; + const BSONObj& hintObj = findCommand.getHint(); + BSONElement hintNaturalElt = hintObj["$natural"]; + + if (sortNaturalElt && sortObj.nFields() != 1) { + return Status(ErrorCodes::BadValue, + str::stream() << "Cannot include '$natural' in compound sort: " << sortObj); + } + + if (hintNaturalElt && hintObj.nFields() != 1) { + return Status(ErrorCodes::BadValue, + str::stream() << "Cannot include '$natural' in compound hint: " << hintObj); + } + + // NEAR cannot have a $natural sort or $natural hint. + if (numGeoNear > 0) { + if (sortNaturalElt) { + return Status(ErrorCodes::BadValue, + "geoNear expression not allowed with $natural sort order"); + } + + if (hintNaturalElt) { + return Status(ErrorCodes::BadValue, + "geoNear expression not allowed with $natural hint"); + } + } + + // TEXT and NEAR cannot both be in the query. + if (numText > 0 && numGeoNear > 0) { + return Status(ErrorCodes::BadValue, "text and geoNear not allowed in same query"); + } + + // TEXT and {$natural: ...} sort order cannot both be in the query. + if (numText > 0 && sortNaturalElt) { + return Status(ErrorCodes::BadValue, "text expression not allowed with $natural sort order"); + } + + // TEXT and hint cannot both be in the query. + if (numText > 0 && !hintObj.isEmpty()) { + return Status(ErrorCodes::BadValue, "text and hint not allowed in same query"); + } + + // TEXT and tailable are incompatible. + if (numText > 0 && findCommand.getTailable()) { + return Status(ErrorCodes::BadValue, "text and tailable cursor not allowed in same query"); + } + + // NEAR and tailable are incompatible. + if (numGeoNear > 0 && findCommand.getTailable()) { + return Status(ErrorCodes::BadValue, + "Tailable cursors and geo $near cannot be used together"); + } + + // $natural sort order must agree with hint. + if (sortNaturalElt) { + if (!hintObj.isEmpty() && !hintNaturalElt) { + return Status(ErrorCodes::BadValue, "index hint not allowed with $natural sort order"); + } + if (hintNaturalElt) { + if (hintNaturalElt.numberInt() != sortNaturalElt.numberInt()) { + return Status(ErrorCodes::BadValue, + "$natural hint must be in the same direction as $natural sort order"); + } + } + } + + return unavailableMetadata; +} + Status CanonicalQuery::isValidNormalized(const MatchExpression* root) { - if (auto numGeoNear = QueryPlannerCommon::countNodes(root, MatchExpression::GEO_NEAR); - numGeoNear > 0) { + if (auto numGeoNear = countNodes(root, MatchExpression::GEO_NEAR); numGeoNear > 0) { tassert(5705300, "Only one geo $near expression is expected", numGeoNear == 1); auto topLevel = false; diff --git a/src/mongo/db/query/canonical_query.h b/src/mongo/db/query/canonical_query.h index 570b71b6fae..98780fb00a1 100644 --- a/src/mongo/db/query/canonical_query.h +++ b/src/mongo/db/query/canonical_query.h @@ -37,7 +37,6 @@ #include "mongo/db/matcher/extensions_callback_noop.h" #include "mongo/db/pipeline/inner_pipeline_stage_interface.h" #include "mongo/db/query/collation/collator_interface.h" -#include "mongo/db/query/parsed_find_command.h" #include "mongo/db/query/projection.h" #include "mongo/db/query/projection_policies.h" #include "mongo/db/query/query_request_helper.h" @@ -77,25 +76,19 @@ public: std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline = {}); /** - * Creates a CanonicalQuery from a ParsedFindCommand. Uses 'expCtx->opCtx', which must be valid. - */ - static StatusWith<std::unique_ptr<CanonicalQuery>> canonicalize( - boost::intrusive_ptr<ExpressionContext> expCtx, - std::unique_ptr<ParsedFindCommand> parsedFind, - bool explain = false, - std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline = {}); - - /** * For testing or for internal clients to use. */ /** - * Construct a 'CanonicalQuery' for a subquery of the given query. This function should only be - * invoked by the subplanner. 'baseQuery' must contain a MatchExpression with rooted $or. This - * function returns a 'CanonicalQuery' housing a copy of the i'th child of the root. + * Used for creating sub-queries from an existing CanonicalQuery. + * + * 'root' must be an expression in baseQuery.root(). + * + * Does not take ownership of 'root'. */ - static StatusWith<std::unique_ptr<CanonicalQuery>> makeForSubplanner( - OperationContext* opCtx, const CanonicalQuery& baseQuery, size_t i); + static StatusWith<std::unique_ptr<CanonicalQuery>> canonicalize(OperationContext* opCtx, + const CanonicalQuery& baseQuery, + MatchExpression* root); /** * Returns true if "query" describes an exact-match query on _id. @@ -103,22 +96,32 @@ public: static bool isSimpleIdQuery(const BSONObj& query); /** - * Perform validation checks on the normalized 'root' which could not be checked before - * normalization - those should happen in parsed_find_command::isValid(). + * Validates the match expression 'root' as well as the query specified by 'request', checking + * for illegal combinations of operators. Returns a non-OK status if any such illegal + * combination is found. + * + * This method can be called both on normalized and non-normalized 'root'. However, some checks + * can only be performed once the match expressions is normalized. To perform these checks one + * can call 'isValidNormalized()'. + * + * On success, returns a bitset indicating which types of metadata are *unavailable*. For + * example, if 'root' does not contain a $text predicate, then the returned metadata bitset will + * indicate that text score metadata is unavailable. This means that if subsequent + * $meta:"textScore" expressions are found during analysis of the query, we should raise in an + * error. */ - static Status isValidNormalized(const MatchExpression* root); + static StatusWith<QueryMetadataBitSet> isValid(const MatchExpression* root, + const FindCommandRequest& findCommand); /** - * For internal use only - but public for accessibility for make_unique(). You must go through - * canonicalize to create a CanonicalQuery. + * Perform additional validation checks on the normalized 'root'. */ - CanonicalQuery() {} + static Status isValidNormalized(const MatchExpression* root); const NamespaceString nss() const { invariant(_findCommand->getNamespaceOrUUID().nss()); return *_findCommand->getNamespaceOrUUID().nss(); } - const std::string ns() const { return nss().ns(); } @@ -197,6 +200,11 @@ public: std::string toStringShort() const; /** + * Returns a count of 'type' nodes in expression tree. + */ + static size_t countNodes(const MatchExpression* root, MatchExpression::MatchType type); + + /** * Returns true if this canonical query may have converted extensions such as $where and $text * into no-ops during parsing. This will be the case if it allowed $where and $text in parsing, * but parsed using an ExtensionsCallbackNoop. This does not guarantee that a $where or $text @@ -257,17 +265,23 @@ public: return _pipeline; } - void optimizeProjection() { - if (_proj) { - _proj->optimize(); - } - } - private: - Status init(boost::intrusive_ptr<ExpressionContext> expCtx, - std::unique_ptr<ParsedFindCommand> parsedFind, - std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline, - bool optimizeMatchExpression); + // You must go through canonicalize to create a CanonicalQuery. + CanonicalQuery() {} + + Status init(OperationContext* opCtx, + boost::intrusive_ptr<ExpressionContext> expCtx, + std::unique_ptr<FindCommandRequest> findCommand, + bool canHaveNoopMatchNodes, + std::unique_ptr<MatchExpression> root, + const ProjectionPolicies& projectionPolicies, + std::vector<std::unique_ptr<InnerPipelineStageInterface>> pipeline); + + // Initializes '_sortPattern', adding any metadata dependencies implied by the sort. + // + // Throws a UserException if the sort is illegal, or if any metadata type in + // 'unavailableMetadata' is required. + void initSortPattern(QueryMetadataBitSet unavailableMetadata); boost::intrusive_ptr<ExpressionContext> _expCtx; diff --git a/src/mongo/db/query/canonical_query_encoder.cpp b/src/mongo/db/query/canonical_query_encoder.cpp index c8a8cd29d48..ccbcce36635 100644 --- a/src/mongo/db/query/canonical_query_encoder.cpp +++ b/src/mongo/db/query/canonical_query_encoder.cpp @@ -74,6 +74,32 @@ bool isQueryNegatingEqualToNull(const mongo::MatchExpression* tree) { namespace { +// Delimiters for cache key encoding. +const char kEncodeChildrenBegin = '['; +const char kEncodeChildrenEnd = ']'; +const char kEncodeChildrenSeparator = ','; +const char kEncodeCollationSection = '#'; +const char kEncodeProjectionSection = '|'; +const char kEncodeProjectionRequirementSeparator = '-'; +const char kEncodeRegexFlagsSeparator = '/'; +const char kEncodeSortSection = '~'; +const char kEncodeEngineSection = '@'; + +// These special bytes are used in the encoding of auto-parameterized match expressions in the SBE +// plan cache key. + +// Precedes the id number of a parameter marker. +const char kEncodeParamMarker = '?'; +// Precedes the encoding of a constant when that constant has not been auto-paramterized. The +// constant is typically encoded as a BSON type byte followed by a BSON value (without the +// BSONElement's field name). +const char kEncodeConstantLiteralMarker = ':'; +// Precedes a byte which encodes the bounds tightness associated with a predicate. The structure of +// the plan (i.e. presence of filters) is affected by bounds tightness. Therefore, if different +// parameter values can result in different tightnesses, this must be explicitly encoded into the +// plan cache key. +const char kEncodeBoundsTightnessDiscriminator = ':'; + /** * AppendChar provides the compiler with a type for a "appendChar(...)" member function. */ @@ -558,7 +584,7 @@ void encodeKeyForProj(const projection_ast::Projection* proj, StringBuilder* key return; } - auto requiredFields = proj->getRequiredFields(); + std::set<std::string> requiredFields = proj->getRequiredFields(); // If the only requirement is that $sortKey be included with some value, we just act as if the // entire document is needed. diff --git a/src/mongo/db/query/canonical_query_encoder.h b/src/mongo/db/query/canonical_query_encoder.h index cf124655681..3164ddbec67 100644 --- a/src/mongo/db/query/canonical_query_encoder.h +++ b/src/mongo/db/query/canonical_query_encoder.h @@ -33,38 +33,6 @@ namespace mongo { -// Delimiters for canonical query portion of cache key encoding. -inline constexpr char kEncodeChildrenBegin = '['; -inline constexpr char kEncodeChildrenEnd = ']'; -inline constexpr char kEncodeChildrenSeparator = ','; -inline constexpr char kEncodeCollationSection = '#'; -inline constexpr char kEncodeProjectionSection = '|'; -inline constexpr char kEncodeProjectionRequirementSeparator = '-'; -inline constexpr char kEncodeRegexFlagsSeparator = '/'; -inline constexpr char kEncodeSortSection = '~'; -inline constexpr char kEncodeEngineSection = '@'; - -// These special bytes are used in the encoding of auto-parameterized match expressions in the SBE -// plan cache key. - -// Precedes the id number of a parameter marker. -inline constexpr char kEncodeParamMarker = '?'; -// Precedes the encoding of a constant when that constant has not been auto-paramterized. The -// constant is typically encoded as a BSON type byte followed by a BSON value (without the -// BSONElement's field name). -inline constexpr char kEncodeConstantLiteralMarker = ':'; -// Precedes a byte which encodes the bounds tightness associated with a predicate. The structure of -// the plan (i.e. presence of filters) is affected by bounds tightness. Therefore, if different -// parameter values can result in different tightnesses, this must be explicitly encoded into the -// plan cache key. -inline constexpr char kEncodeBoundsTightnessDiscriminator = ':'; - -// Delimiters for the discriminator portion of the cache key encoding. -inline constexpr char kEncodeDiscriminatorsBegin = '<'; -inline constexpr char kEncodeDiscriminatorsEnd = '>'; -inline constexpr char kEncodeGlobalDiscriminatorsBegin = '('; -inline constexpr char kEncodeGlobalDiscriminatorsEnd = ')'; - /** * Returns true if the query predicate involves a negation of an EQ, LTE, or GTE comparison to * 'null'. diff --git a/src/mongo/db/query/canonical_query_test.cpp b/src/mongo/db/query/canonical_query_test.cpp index 5cba0bcc3f4..dbb2fd929da 100644 --- a/src/mongo/db/query/canonical_query_test.cpp +++ b/src/mongo/db/query/canonical_query_test.cpp @@ -279,52 +279,11 @@ TEST(CanonicalQueryTest, CanonicalizeFromBaseQuery) { assertGet(CanonicalQuery::canonicalize(opCtx.get(), std::move(findCommand), isExplain)); MatchExpression* firstClauseExpr = baseCq->root()->getChild(0); - auto childCq = assertGet(CanonicalQuery::makeForSubplanner(opCtx.get(), *baseCq, 0)); + auto childCq = assertGet(CanonicalQuery::canonicalize(opCtx.get(), *baseCq, firstClauseExpr)); - ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getFilter(), firstClauseExpr->serialize()); - - ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getProjection(), - baseCq->getFindCommandRequest().getProjection()); - ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getSort(), - baseCq->getFindCommandRequest().getSort()); - ASSERT_TRUE(childCq->getExplain()); -} - -TEST(CanonicalQueryTest, CanonicalizeFromBaseQueryWithSpecialFeature) { - // Like the above test, but use $text which is a 'special feature' not always allowed. This is - // meant to reproduce SERVER-XYZ. - QueryTestServiceContext serviceContext; - auto opCtx = serviceContext.makeOperationContext(); - - const bool isExplain = true; - const std::string cmdStr = R"({ - find:'bogusns', - filter: { - $or:[ - {a: 'foo'}, - {$text: {$search: 'bar'}} - ] - }, - projection: {a:1}, - sort: {b:1}, - $db: 'test' - })"; - auto findCommand = query_request_helper::makeFromFindCommandForTests(fromjson(cmdStr)); - auto baseCq = - assertGet(CanonicalQuery::canonicalize(opCtx.get(), - std::move(findCommand), - isExplain, - nullptr, - ExtensionsCallbackNoop(), - MatchExpressionParser::kAllowAllSpecialFeatures)); - - // Note: be sure to use the second child to get $text, since we 'normalize' and sort the - // MatchExpression tree as part of canonicalization. This will put the text search clause - // second. - MatchExpression* secondClauseExpr = baseCq->root()->getChild(1); - auto childCq = assertGet(CanonicalQuery::makeForSubplanner(opCtx.get(), *baseCq, 1)); - - ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getFilter(), secondClauseExpr->serialize()); + BSONObjBuilder expectedFilter; + firstClauseExpr->serialize(&expectedFilter); + ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getFilter(), expectedFilter.obj()); ASSERT_BSONOBJ_EQ(childCq->getFindCommandRequest().getProjection(), baseCq->getFindCommandRequest().getProjection()); @@ -361,7 +320,8 @@ TEST(CanonicalQueryTest, CanonicalQueryFromBaseQueryWithNoCollation) { auto findCommand = std::make_unique<FindCommandRequest>(nss); findCommand->setFilter(fromjson("{$or:[{a:1,b:1},{a:1,c:1}]}")); auto baseCq = assertGet(CanonicalQuery::canonicalize(opCtx.get(), std::move(findCommand))); - auto childCq = assertGet(CanonicalQuery::makeForSubplanner(opCtx.get(), *baseCq, 0)); + MatchExpression* firstClauseExpr = baseCq->root()->getChild(0); + auto childCq = assertGet(CanonicalQuery::canonicalize(opCtx.get(), *baseCq, firstClauseExpr)); ASSERT_TRUE(baseCq->getCollator() == nullptr); ASSERT_TRUE(childCq->getCollator() == nullptr); } @@ -375,7 +335,8 @@ TEST(CanonicalQueryTest, CanonicalQueryFromBaseQueryWithCollation) { findCommand->setCollation(BSON("locale" << "reverse")); auto baseCq = assertGet(CanonicalQuery::canonicalize(opCtx.get(), std::move(findCommand))); - auto childCq = assertGet(CanonicalQuery::makeForSubplanner(opCtx.get(), *baseCq, 0)); + MatchExpression* firstClauseExpr = baseCq->root()->getChild(0); + auto childCq = assertGet(CanonicalQuery::canonicalize(opCtx.get(), *baseCq, firstClauseExpr)); ASSERT(baseCq->getCollator()); ASSERT(childCq->getCollator()); ASSERT_TRUE(*(childCq->getCollator()) == *(baseCq->getCollator())); diff --git a/src/mongo/db/query/classic_plan_cache.h b/src/mongo/db/query/classic_plan_cache.h index e510b48dd6d..8d2e6889bfb 100644 --- a/src/mongo/db/query/classic_plan_cache.h +++ b/src/mongo/db/query/classic_plan_cache.h @@ -235,12 +235,7 @@ using PlanCacheEntry = PlanCacheEntryBase<SolutionCacheData, plan_cache_debug_in using CachedSolution = CachedPlanHolder<SolutionCacheData, plan_cache_debug_info::DebugInfo>; struct BudgetEstimator { - /** - * This estimator function is called when an entry is added or removed to LRU cache in order to - * make sure the total plan cache size does not exceed the maximum size. - */ - - size_t operator()(const PlanCacheKey&, const std::shared_ptr<const PlanCacheEntry>&) { + size_t operator()(const std::shared_ptr<const PlanCacheEntry>&) { return 1; } }; diff --git a/src/mongo/db/query/collection_query_info.cpp b/src/mongo/db/query/collection_query_info.cpp index ff4e430f6a1..e624389b642 100644 --- a/src/mongo/db/query/collection_query_info.cpp +++ b/src/mongo/db/query/collection_query_info.cpp @@ -90,13 +90,12 @@ CollectionQueryInfo::PlanCacheState::PlanCacheState(OperationContext* opCtx, // TODO We shouldn't need to include unfinished indexes, but we must here because the index // catalog may be in an inconsistent state. SERVER-18346. - auto ii = collection->getIndexCatalog()->getIndexIterator( - opCtx, IndexCatalog::InclusionPolicy::kReady | IndexCatalog::InclusionPolicy::kUnfinished); + const bool includeUnfinishedIndexes = true; + std::unique_ptr<IndexCatalog::IndexIterator> ii = + collection->getIndexCatalog()->getIndexIterator(opCtx, includeUnfinishedIndexes); while (ii->more()) { const IndexCatalogEntry* ice = ii->next(); - if (ice->accessMethod()) { - indexCores.emplace_back(indexInfoFromIndexCatalogEntry(*ice)); - } + indexCores.emplace_back(indexInfoFromIndexCatalogEntry(*ice)); } planCacheIndexabilityState.updateDiscriminators(indexCores); @@ -118,8 +117,8 @@ const UpdateIndexData& CollectionQueryInfo::getIndexKeys(OperationContext* opCtx void CollectionQueryInfo::computeIndexKeys(OperationContext* opCtx, const CollectionPtr& coll) { _indexedPaths.clear(); - auto it = coll->getIndexCatalog()->getIndexIterator( - opCtx, IndexCatalog::InclusionPolicy::kReady | IndexCatalog::InclusionPolicy::kUnfinished); + std::unique_ptr<IndexCatalog::IndexIterator> it = + coll->getIndexCatalog()->getIndexIterator(opCtx, true); while (it->more()) { const IndexCatalogEntry* entry = it->next(); const IndexDescriptor* descriptor = entry->descriptor(); @@ -176,10 +175,10 @@ void CollectionQueryInfo::computeIndexKeys(OperationContext* opCtx, const Collec // handle partial indexes const MatchExpression* filter = entry->getFilterExpression(); if (filter) { - RelevantFieldIndexMap paths; + stdx::unordered_set<std::string> paths; QueryPlannerIXSelect::getFields(filter, &paths); for (auto it = paths.begin(); it != paths.end(); ++it) { - _indexedPaths.addPath(FieldRef(it->first)); + _indexedPaths.addPath(FieldRef(*it)); } } } @@ -239,8 +238,9 @@ void CollectionQueryInfo::updatePlanCacheIndexEntries(OperationContext* opCtx, } void CollectionQueryInfo::init(OperationContext* opCtx, const CollectionPtr& coll) { - auto ii = - coll->getIndexCatalog()->getIndexIterator(opCtx, IndexCatalog::InclusionPolicy::kReady); + const bool includeUnfinishedIndexes = false; + std::unique_ptr<IndexCatalog::IndexIterator> ii = + coll->getIndexCatalog()->getIndexIterator(opCtx, includeUnfinishedIndexes); while (ii->more()) { const IndexDescriptor* desc = ii->next()->descriptor(); CollectionIndexUsageTrackerDecoration::get(coll->getSharedDecorations()) diff --git a/src/mongo/db/query/datetime/date_time_support.cpp b/src/mongo/db/query/datetime/date_time_support.cpp index 93859935c98..1fe0ecd81d0 100644 --- a/src/mongo/db/query/datetime/date_time_support.cpp +++ b/src/mongo/db/query/datetime/date_time_support.cpp @@ -842,7 +842,7 @@ StringData serializeTimeUnit(TimeUnit unit) { case TimeUnit::millisecond: return "millisecond"_sd; } - MONGO_UNREACHABLE_TASSERT(5339903); + MONGO_UNREACHABLE_TASSERT(5339900); } DayOfWeek parseDayOfWeek(StringData dayOfWeek) { diff --git a/src/mongo/db/query/datetime/date_time_support_test.cpp b/src/mongo/db/query/datetime/date_time_support_test.cpp index df6e97c979a..d2b2e3b2d44 100644 --- a/src/mongo/db/query/datetime/date_time_support_test.cpp +++ b/src/mongo/db/query/datetime/date_time_support_test.cpp @@ -2629,10 +2629,7 @@ TEST(DateAdd, DateAddWithTimezoneDST) { {europeAmsterdamZone.createFromDateParts(2020, 10, 24, 2, 0, 1, 0), TimeUnit::day, 1, - europeAmsterdamZone.createFromDateParts(2020, 10, 25, 1, 59, 59, 0) + - Milliseconds{2000}}, // as this date is ambiguous (it could in both timezones, with or - // without DST) and the computation is expected to return the - // "with DST" one, obtain it via a computation + europeAmsterdamZone.createFromDateParts(2020, 10, 25, 2, 0, 1, 0)}, {europeAmsterdamZone.createFromDateParts(2020, 10, 24, 3, 0, 1, 0), TimeUnit::day, 1, @@ -2724,13 +2721,10 @@ TEST(DateAdd, DateAddWithTimezoneDST) { TimeUnit::day, 1, newYorkZone.createFromDateParts(2020, 11, 2, 1, 30, 0, 0)}, - {newYorkZone.createFromDateParts(2020, 10, 31, 1, 0, 1, 0), + {newYorkZone.createFromDateParts(2020, 10, 31, 1, 30, 0, 0), TimeUnit::day, 1, - newYorkZone.createFromDateParts(2020, 11, 1, 0, 59, 59, 0) + - Milliseconds{2000}}, // as this date is ambiguous (it could in both timezones, with or - // without DST) and the computation is expected to return the - // "with DST" one, obtain it via a computation + newYorkZone.createFromDateParts(2020, 11, 1, 1, 30, 0, 0)}, {newYorkZone.createFromDateParts(2020, 11, 1, 3, 0, 0, 0), TimeUnit::day, -1, @@ -2791,20 +2785,15 @@ TEST(DateAdd, DateAdd_LordHoweTimezoneDST) { auto australiaLordHoweZone = kDefaultTimeZoneDatabase.getTimeZone("Australia/Lord_Howe"); std::vector<TestCase> tests{ // DST to Standard change: 2021-04-04T02:00:00 -> 2021-04-04T01:30:00 Lord Howe timezone. - {australiaLordHoweZone.createFromDateParts(2021, 4, 4, 1, 29, 59, 0) + - Milliseconds{1000}, // as this date is ambiguous (it could in both timezones, with or - // without DST) and the computation is expected to start from the - // "with DST" one, obtain it via a computation + {australiaLordHoweZone.createFromDateParts(2021, 4, 4, 1, 30, 0, 0), TimeUnit::day, 1, australiaLordHoweZone.createFromDateParts(2021, 4, 5, 1, 30, 0, 0)}, - {australiaLordHoweZone.createFromDateParts(2021, 4, 3, 1, 30, 1, 0), + {australiaLordHoweZone.createFromDateParts(2021, 4, 3, 1, 45, 0, 0), TimeUnit::day, 1, - australiaLordHoweZone.createFromDateParts(2021, 4, 4, 1, 29, 59, 0) + - Milliseconds{2000}}, // as this date is ambiguous (it could in both timezones, with or - // without DST) and the computation is expected to return the - // "with DST" one, obtain it via a computation + // Computed time falls into the repeated 1/2 hour. + australiaLordHoweZone.createFromDateParts(2021, 4, 4, 1, 45, 0, 0)}, {australiaLordHoweZone.createFromDateParts(2021, 4, 5, 1, 0, 0, 0), TimeUnit::day, -1, diff --git a/src/mongo/db/query/explain.cpp b/src/mongo/db/query/explain.cpp index 796875bca68..414badb8332 100644 --- a/src/mongo/db/query/explain.cpp +++ b/src/mongo/db/query/explain.cpp @@ -124,7 +124,7 @@ void generatePlannerInfo(PlanExecutor* exec, auto query = exec->getCanonicalQuery(); if (nullptr != query) { BSONObjBuilder parsedQueryBob(plannerBob.subobjStart("parsedQuery")); - query->root()->serialize(&parsedQueryBob, {}); + query->root()->serialize(&parsedQueryBob); parsedQueryBob.doneFast(); if (query->getCollator()) { diff --git a/src/mongo/db/query/find.cpp b/src/mongo/db/query/find.cpp index cd8e21bf6c7..d2f36155e13 100644 --- a/src/mongo/db/query/find.cpp +++ b/src/mongo/db/query/find.cpp @@ -107,28 +107,19 @@ void endQueryOp(OperationContext* opCtx, const CollectionPtr& collection, const PlanExecutor& exec, long long numResults, - boost::optional<ClientCursorPin&> cursor, - const BSONObj& cmdObj) { + CursorId cursorId) { auto curOp = CurOp::get(opCtx); - // Fill out basic CurOp query exec properties. More metrics (nreturned and executionTime) - // are collected within collectQueryStatsMongod. - curOp->debug().cursorid = (cursor.has_value() ? cursor->getCursor()->cursorid() : -1); - curOp->debug().cursorExhausted = !cursor.has_value(); - curOp->debug().additiveMetrics.nBatches = 1; + // Fill out basic CurOp query exec properties. + curOp->debug().nreturned = numResults; + curOp->debug().cursorid = (0 == cursorId ? -1 : cursorId); + curOp->debug().cursorExhausted = (0 == cursorId); // Fill out CurOp based on explain summary statistics. PlanSummaryStats summaryStats; auto&& explainer = exec.getPlanExplainer(); explainer.getSummaryStats(&summaryStats); curOp->debug().setPlanSummaryMetrics(summaryStats); - curOp->setEndOfOpMetrics(numResults); - - if (cursor) { - collectQueryStatsMongod(opCtx, *cursor); - } else { - collectQueryStatsMongod(opCtx, std::move(curOp->debug().queryStatsInfo.key)); - } if (collection) { CollectionQueryInfo::get(collection).notifyOfQuery(opCtx, collection, summaryStats); diff --git a/src/mongo/db/query/find.h b/src/mongo/db/query/find.h index 235ebf91ed8..2b45efcd602 100644 --- a/src/mongo/db/query/find.h +++ b/src/mongo/db/query/find.h @@ -73,7 +73,6 @@ void endQueryOp(OperationContext* opCtx, const CollectionPtr& collection, const PlanExecutor& exec, long long numResults, - boost::optional<ClientCursorPin&> cursor, - const BSONObj& cmdObj); + CursorId cursorId); } // namespace mongo diff --git a/src/mongo/db/query/find_common.cpp b/src/mongo/db/query/find_common.cpp index 0078533cc60..57f9f3954b2 100644 --- a/src/mongo/db/query/find_common.cpp +++ b/src/mongo/db/query/find_common.cpp @@ -133,17 +133,5 @@ std::size_t FindCommon::getBytesToReserveForGetMoreReply(bool isTailable, // command metadata to the reply. return kMaxBytesToReturnToClientAtOnce; } -bool FindCommon::BSONArrayResponseSizeTracker::haveSpaceForNext(const BSONObj& document) { - return FindCommon::haveSpaceForNext(document, _numberOfDocuments, _bsonArraySizeInBytes); -} -void FindCommon::BSONArrayResponseSizeTracker::add(const BSONObj& document) { - dassert(haveSpaceForNext(document)); - ++_numberOfDocuments; - _bsonArraySizeInBytes += (document.objsize() + kPerDocumentOverheadBytesUpperBound); -} -// Upper bound of BSON array element overhead. The overhead is 1 byte/doc for the type + 1 byte/doc -// for the field name's null terminator + 1 byte per digit of the maximum array index value. -const size_t FindCommon::BSONArrayResponseSizeTracker::kPerDocumentOverheadBytesUpperBound{ - 2 + std::to_string(BSONObjMaxUserSize / BSONObj::kMinBSONLength).length()}; } // namespace mongo diff --git a/src/mongo/db/query/find_common.h b/src/mongo/db/query/find_common.h index d38d580bdd2..45f60d2fd51 100644 --- a/src/mongo/db/query/find_common.h +++ b/src/mongo/db/query/find_common.h @@ -89,7 +89,7 @@ public: // This max may be exceeded by epsilon for output documents that approach the maximum user // document size. That is, if we must return a BSONObjMaxUserSize document, then the total // response size will be BSONObjMaxUserSize plus the amount of size required for the message - // header and the cursor response "envelope". (The envelope contains namespace and cursor id + // header and the cursor response "envelope". (The envolope contains namespace and cursor id // info.) static const size_t kMaxBytesToReturnToClientAtOnce; @@ -148,32 +148,6 @@ public: static std::size_t getBytesToReserveForGetMoreReply(bool isTailable, size_t firstResultSize, size_t batchSize); - - /** - * Tracker of a size of a server response presented as a BSON array. Facilitates limiting the - * server response size to 16MB + certain epsilon. Accounts for array element and it's overhead - * size. Does not account for response "envelope" size. - */ - class BSONArrayResponseSizeTracker { - // Upper bound of BSON array element overhead. - static const size_t kPerDocumentOverheadBytesUpperBound; - - public: - /** - * Returns true only if 'document' can be added to the BSON array without violating the - * overall response size limit or if it is the first document. - */ - bool haveSpaceForNext(const BSONObj& document); - - /** - * Records that 'document' was added to the response. - */ - void add(const BSONObj& document); - - private: - std::size_t _numberOfDocuments{0}; - std::size_t _bsonArraySizeInBytes{0}; - }; }; } // namespace mongo diff --git a/src/mongo/db/query/find_common_test.cpp b/src/mongo/db/query/find_common_test.cpp deleted file mode 100644 index d7dfc10d950..00000000000 --- a/src/mongo/db/query/find_common_test.cpp +++ /dev/null @@ -1,74 +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 "mongo/platform/basic.h" - -#include <string> - -#include "mongo/bson/bsonobj.h" -#include "mongo/bson/bsonobjbuilder.h" -#include "mongo/db/query/find_common.h" - -#include "mongo/unittest/unittest.h" - -namespace { - -using namespace mongo; - -TEST(BSONArrayResponseSizeTrackerTest, AddLargeNumberOfElements) { - BSONObjBuilder bsonObjBuilder; - { - FindCommon::BSONArrayResponseSizeTracker sizeTracker; - BSONArrayBuilder arrayBuilder{bsonObjBuilder.subarrayStart("a")}; - BSONObj emptyObject; - while (sizeTracker.haveSpaceForNext(emptyObject)) { - sizeTracker.add(emptyObject); - arrayBuilder.append(emptyObject); - } - } - // If the BSON object is successfully constructed, then space accounting was correct. - bsonObjBuilder.obj(); -} -TEST(BSONArrayResponseSizeTrackerTest, CanAddAtLeastOneDocument) { - auto largeObject = BSON("a" << std::string(16 * 1024 * 1024, 'A')); - BSONObj emptyObject; - BSONObjBuilder bsonObjBuilder; - { - FindCommon::BSONArrayResponseSizeTracker sizeTracker; - BSONArrayBuilder arrayBuilder{bsonObjBuilder.subarrayStart("a")}; - // Add an object that is larger than 16MB. - ASSERT(sizeTracker.haveSpaceForNext(largeObject)); - sizeTracker.add(largeObject); - arrayBuilder.append(largeObject); - ASSERT(!sizeTracker.haveSpaceForNext(emptyObject)); - } - // If the BSON object is successfully constructed, then space accounting was correct. - bsonObjBuilder.obj(); -} -} // namespace diff --git a/src/mongo/db/query/get_executor.cpp b/src/mongo/db/query/get_executor.cpp index 602be15dbc2..db04d6a276a 100644 --- a/src/mongo/db/query/get_executor.cpp +++ b/src/mongo/db/query/get_executor.cpp @@ -29,13 +29,10 @@ #define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery -#include "mongo/db/curop.h" #include "mongo/platform/basic.h" #include "mongo/db/query/get_executor.h" -#include "mongo/util/duration.h" -#include "mongo/util/tick_source.h" #include <boost/optional.hpp> #include <limits> #include <memory> @@ -110,7 +107,6 @@ #include "mongo/logv2/log.h" #include "mongo/scripting/engine.h" #include "mongo/util/str.h" -#include "mongo/util/timer.h" namespace mongo { MONGO_FAIL_POINT_DEFINE(includeFakeColumnarIndex); @@ -220,15 +216,10 @@ IndexEntry indexEntryFromIndexCatalogEntry(OperationContext* opCtx, MultikeyMetadataAccessStats mkAccessStats; if (canonicalQuery) { - RelevantFieldIndexMap fieldIndexProps; - QueryPlannerIXSelect::getFields(canonicalQuery->root(), &fieldIndexProps); - stdx::unordered_set<std::string> projectedFields; - for (auto&& [fieldName, _] : fieldIndexProps) { - if (projection_executor_utils::applyProjectionToOneField( - wildcardProjection->exec(), fieldName)) { - projectedFields.insert(fieldName); - } - } + stdx::unordered_set<std::string> fields; + QueryPlannerIXSelect::getFields(canonicalQuery->root(), &fields); + const auto projectedFields = projection_executor_utils::applyProjectionToFields( + wildcardProjection->exec(), fields); multikeyPathSet = getWildcardMultikeyPathSet(wam, opCtx, projectedFields, &mkAccessStats); @@ -293,8 +284,7 @@ void fillOutIndexEntries(OperationContext* opCtx, const CanonicalQuery* canonicalQuery, const CollectionPtr& collection, std::vector<IndexEntry>& entries) { - auto ii = collection->getIndexCatalog()->getIndexIterator( - opCtx, IndexCatalog::InclusionPolicy::kReady); + auto ii = collection->getIndexCatalog()->getIndexIterator(opCtx, false); while (ii->more()) { const IndexCatalogEntry* ice = ii->next(); @@ -607,8 +597,6 @@ public: StatusWith<std::unique_ptr<ResultType>> prepare() { const auto& mainColl = getMainCollection(); - - ON_BLOCK_EXIT([&] { CurOp::get(_opCtx)->stopQueryPlanningTimer(); }); if (!mainColl) { LOGV2_DEBUG(20921, 2, @@ -708,8 +696,10 @@ public: "Only one plan is available", "query"_attr = redact(_cq->toStringShort()), "planSummary"_attr = result->getPlanSummary()); + return std::move(result); } + return buildMultiPlan(std::move(solutions)); } @@ -1278,12 +1268,12 @@ std::unique_ptr<sbe::RuntimePlanner> makeRuntimePlannerIfNeeded( return nullptr; } -std::unique_ptr<PlanYieldPolicySBE> makeSbeYieldPolicy(OperationContext* opCtx, - PlanYieldPolicy::YieldPolicy policy, - const Yieldable* yieldable, - NamespaceString nss) { - return std::make_unique<PlanYieldPolicySBE>(opCtx, - policy, +std::unique_ptr<PlanYieldPolicySBE> makeSbeYieldPolicy( + OperationContext* opCtx, + PlanYieldPolicy::YieldPolicy requestedYieldPolicy, + const Yieldable* yieldable, + NamespaceString nss) { + return std::make_unique<PlanYieldPolicySBE>(requestedYieldPolicy, opCtx->getServiceContext()->getFastClockSource(), internalQueryExecYieldIterations.load(), Milliseconds{internalQueryExecYieldPeriodMS.load()}, @@ -1321,16 +1311,16 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getSlotBasedExe auto&& [roots, solutions] = planningResult->extractResultData(); // In some circumstances (e.g. when have multiple candidate plans or using a cached one), we // might need to execute the plan(s) to pick the best one or to confirm the choice. - if (auto runTimePlanner = makeRuntimePlannerIfNeeded(opCtx, - collections, - cq.get(), - solutions.size(), - planningResult->decisionWorks(), - planningResult->needsSubplanning(), - yieldPolicy.get(), - plannerParams.options)) { + if (auto planner = makeRuntimePlannerIfNeeded(opCtx, + collections, + cq.get(), + solutions.size(), + planningResult->decisionWorks(), + planningResult->needsSubplanning(), + yieldPolicy.get(), + plannerParams.options)) { // Do the runtime planning and pick the best candidate plan. - auto candidates = runTimePlanner->plan(std::move(solutions), std::move(roots)); + auto candidates = planner->plan(std::move(solutions), std::move(roots)); return plan_executor_factory::make(opCtx, std::move(cq), @@ -1401,11 +1391,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutor( } } - // There's a special case of the projection optimization being skipped when a query has any - // user-defined "let" variable and the query may be run with SBE. Here we make sure the - // projection is optimized for the classic engine. - canonicalQuery->optimizeProjection(); - return getClassicExecutor( opCtx, mainColl, std::move(canonicalQuery), yieldPolicy, plannerParams); } @@ -1418,7 +1403,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutor( PlanYieldPolicy::YieldPolicy yieldPolicy, size_t plannerOptions) { MultipleCollectionAccessor multi{collection}; - return getExecutor(opCtx, multi, std::move(canonicalQuery), @@ -1438,8 +1422,9 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorFind std::function<void(CanonicalQuery*)> extractAndAttachPipelineStages, bool permitYield, QueryPlannerParams plannerParams) { - auto yieldPolicy = permitYield ? PlanYieldPolicy::YieldPolicy::YIELD_AUTO - : PlanYieldPolicy::YieldPolicy::INTERRUPT_ONLY; + auto yieldPolicy = (permitYield && !opCtx->inMultiDocumentTransaction()) + ? PlanYieldPolicy::YieldPolicy::YIELD_AUTO + : PlanYieldPolicy::YieldPolicy::INTERRUPT_ONLY; if (OperationShardingState::isComingFromRouter(opCtx)) { plannerParams.options |= QueryPlannerParams::INCLUDE_SHARD_FILTER; @@ -1460,7 +1445,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorFind std::function<void(CanonicalQuery*)> extractAndAttachPipelineStages, bool permitYield, size_t plannerOptions) { - MultipleCollectionAccessor multi{*coll}; return getExecutorFind(opCtx, multi, @@ -1542,13 +1526,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorDele expCtx->setIsCappedDelete(); } - // If the parsed delete does not have a user-specified collation, set it from the collection - // default. - if (collection && parsedDelete->getRequest()->getCollation().isEmpty() && - collection->getDefaultCollator()) { - parsedDelete->setCollator(collection->getDefaultCollator()->clone()); - } - if (collection && collection->isCapped() && opCtx->inMultiDocumentTransaction()) { // This check is duplicated from CollectionImpl::deleteDocument() for two reasons: // - Performing a remove on an empty capped collection would not call @@ -1676,7 +1653,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorDele ClassicPrepareExecutionHelper helper{ opCtx, collection, ws.get(), cq.get(), nullptr, defaultPlannerOptions}; auto executionResult = helper.prepare(); - if (!executionResult.isOK()) { return executionResult.getStatus(); } @@ -1686,9 +1662,9 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorDele deleteStageParams->canonicalQuery = cq.get(); const bool batchDelete = - (deleteStageParams->isMulti && !opCtx->inMultiDocumentTransaction() && - !deleteStageParams->fromMigrate && !deleteStageParams->returnDeleted && - deleteStageParams->sort.isEmpty() && !deleteStageParams->numStatsForDoc) && + (deleteStageParams->isMulti && !deleteStageParams->fromMigrate && + !deleteStageParams->returnDeleted && deleteStageParams->sort.isEmpty() && + !deleteStageParams->numStatsForDoc) && ((gInternalBatchUserMultiDeletesForTest.load() && nss.ns() == "__internalBatchedDeletesTesting.Collection0") || (batchDeletesByDefault.shouldFail())); @@ -1864,7 +1840,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorUpda ClassicPrepareExecutionHelper helper{ opCtx, collection, ws.get(), cq.get(), nullptr, defaultPlannerOptions}; auto executionResult = helper.prepare(); - if (!executionResult.isOK()) { return executionResult.getStatus(); } @@ -2138,8 +2113,8 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorCoun OperationContext* opCtx = expCtx->opCtx; std::unique_ptr<WorkingSet> ws = std::make_unique<WorkingSet>(); - auto findCommand = std::make_unique<FindCommandRequest>(nss); + auto findCommand = std::make_unique<FindCommandRequest>(nss); findCommand->setFilter(request.getQuery()); auto collation = request.getCollation().value_or(BSONObj()); findCommand->setCollation(collation); @@ -2160,7 +2135,9 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorCoun } std::unique_ptr<CanonicalQuery> cq = std::move(statusWithCQ.getValue()); - const auto yieldPolicy = PlanYieldPolicy::YieldPolicy::YIELD_AUTO; + const auto yieldPolicy = opCtx->inMultiDocumentTransaction() + ? PlanYieldPolicy::YieldPolicy::INTERRUPT_ONLY + : PlanYieldPolicy::YieldPolicy::YIELD_AUTO; const auto skip = request.getSkip().value_or(0); const auto limit = request.getLimit().value_or(0); @@ -2213,7 +2190,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorCoun if (!executionResult.isOK()) { return executionResult.getStatus(); } - auto [root, querySolution] = executionResult.getValue()->extractResultData(); invariant(root); @@ -2222,7 +2198,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorCoun expCtx.get(), collection, limit, skip, ws.get(), root.release()); // We must have a tree of stages in order to have a valid plan executor, but the query // solution may be NULL. Takes ownership of all args other than 'collection' and 'opCtx' - return plan_executor_factory::make(std::move(cq), std::move(ws), std::move(root), @@ -2418,8 +2393,8 @@ QueryPlannerParams fillOutPlannerParamsForDistinct(OperationContext* opCtx, // If the caller did not request a "strict" distinct scan then we may choose a plan which // unwinds arrays and treats each element in an array as its own key. const bool mayUnwindArrays = !(plannerOptions & QueryPlannerParams::STRICT_DISTINCT_ONLY); - auto ii = collection->getIndexCatalog()->getIndexIterator( - opCtx, IndexCatalog::InclusionPolicy::kReady); + std::unique_ptr<IndexCatalog::IndexIterator> ii = + collection->getIndexCatalog()->getIndexIterator(opCtx, false); auto query = parsedDistinct.getQuery()->getFindCommandRequest().getFilter(); while (ii->more()) { const IndexCatalogEntry* ice = ii->next(); @@ -2657,7 +2632,9 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> getExecutorDist auto expCtx = parsedDistinct->getQuery()->getExpCtx(); OperationContext* opCtx = expCtx->opCtx; - const auto yieldPolicy = PlanYieldPolicy::YieldPolicy::YIELD_AUTO; + const auto yieldPolicy = opCtx->inMultiDocumentTransaction() + ? PlanYieldPolicy::YieldPolicy::INTERRUPT_ONLY + : PlanYieldPolicy::YieldPolicy::YIELD_AUTO; if (!collection) { // Treat collections that do not exist as empty collections. diff --git a/src/mongo/db/query/index_bounds.cpp b/src/mongo/db/query/index_bounds.cpp index 16985de29a0..ecb1f21208b 100644 --- a/src/mongo/db/query/index_bounds.cpp +++ b/src/mongo/db/query/index_bounds.cpp @@ -244,24 +244,10 @@ bool OrderedIntervalList::isMinToMax() const { return intervals.size() == 1 && intervals[0].isMinToMax(); } -bool OrderedIntervalList::isMaxToMin() const { - return intervals.size() == 1 && intervals[0].isMaxToMin(); -} - bool OrderedIntervalList::isPoint() const { return intervals.size() == 1 && intervals[0].isPoint(); } -bool OrderedIntervalList::containsOnlyPointIntervals() const { - for (const auto& interval : intervals) { - if (!interval.isPoint()) { - return false; - } - } - - return true; -} - // static void OrderedIntervalList::complement() { BSONObjBuilder minBob; diff --git a/src/mongo/db/query/index_bounds.h b/src/mongo/db/query/index_bounds.h index de457282224..d828f275164 100644 --- a/src/mongo/db/query/index_bounds.h +++ b/src/mongo/db/query/index_bounds.h @@ -95,22 +95,12 @@ struct OrderedIntervalList { bool isMinToMax() const; /** - * Returns true if this OIL represents a single [MaxKey, MinKey] bound. - */ - bool isMaxToMin() const; - - /** * Returns true if this OIL represents a point predicate: [N, N]. * * These predicates are interesting because if you have an index on {a:1, b:1}, * and a point predicate on 'a', then the index provides a sort on {b: 1}. */ bool isPoint() const; - - /** - * Returns true if this OIL contains only point intervals (such as [N, N]). - */ - bool containsOnlyPointIntervals() const; }; /** diff --git a/src/mongo/db/query/index_bounds_builder.cpp b/src/mongo/db/query/index_bounds_builder.cpp index 3c027bde140..01e13b5f058 100644 --- a/src/mongo/db/query/index_bounds_builder.cpp +++ b/src/mongo/db/query/index_bounds_builder.cpp @@ -108,38 +108,13 @@ Interval makeNullPointInterval(bool isHashed) { return isHashed ? kHashedNullInterval : IndexBoundsBuilder::kNullPointInterval; } -/** - * This helper updates the query bounds tightness for the limited set of conditions where we see a - * null query that can be covered. - */ -void updateTightnessForNullQuery(const IndexEntry& index, - IndexBoundsBuilder::BoundsTightness* tightnessOut) { - if (index.sparse || index.type == IndexType::INDEX_HASHED) { - // Sparse indexes and hashed indexes require a FETCH stage with a filter for null queries. - *tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; - return; - } - - if (index.multikey) { - // If we have a simple equality null query and our index is multikey, we cannot cover the - // query. This is because null intervals are translated into the null and undefined point - // intervals, and the undefined point interval includes entries for []. In the case of a - // single null interval, [] should not match. - *tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; - return; - } - - // The query may be fully covered by the index if the projection allows it, since the case above - // about the empty array can only become an issue if there is an empty array present, which - // would mark the index as multikey. - *tightnessOut = IndexBoundsBuilder::EXACT_MAYBE_COVERED; -} - void makeNullEqualityBounds(const IndexEntry& index, bool isHashed, OrderedIntervalList* oil, IndexBoundsBuilder::BoundsTightness* tightnessOut) { - updateTightnessForNullQuery(index, tightnessOut); + // An equality to null predicate cannot be covered because the index does not distinguish + // between the lack of a value and the literal value null. + *tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; // There are two values that could possibly be equal to null in an index: undefined and null. oil->intervals.push_back(makeUndefinedPointInterval(isHashed)); @@ -279,10 +254,7 @@ bool IndexBoundsBuilder::canUseCoveredMatching(const MatchExpression* expr, IndexBoundsBuilder::BoundsTightness tightness; OrderedIntervalList oil; translate(expr, BSONElement{}, index, &oil, &tightness, /* iet::Builder */ nullptr); - // We have additional tightness values (MAYBE_COVERED), but we cannot generally cover those - // cases unless we have an appropriate projection. - return tightness == IndexBoundsBuilder::INEXACT_COVERED || - tightness == IndexBoundsBuilder::EXACT; + return tightness >= IndexBoundsBuilder::INEXACT_COVERED; } // static @@ -432,61 +404,6 @@ const Interval IndexBoundsBuilder::kNullPointInterval = const Interval IndexBoundsBuilder::kEmptyArrayPointInterval = IndexBoundsBuilder::makePointInterval(kEmptyArrayElementObj); -bool detectIfEntireNullIntervalMatchesPredicate(const InMatchExpression* ime, - const IndexEntry& index) { - if (!ime->hasNull()) { - // This isn't a null query. - return false; - } - - if (index.sparse || (IndexType::INDEX_HASHED == index.type)) { - // Sparse indexes and hashed indexes still require a FETCH stage with a filter for null - // queries. - return false; - } - - // Given the context of having a null $in query with eligible indexes, we may be able to cover - // some combinations of intervals that we could not cover individually. - if (index.multikey) { - // If the path has multiple components and we have a multikey index, we still need a FETCH - // in order to defend against cases where we have a multikey index on "a". These documents - // will generate null index keys: {"a.b": null} and {a: [1,2,3]}. However, a query like - // {"a.b": {$in: [null, []]}} should not match {a: [1, 2, 3]}. - // TODO SERVER-71021: it may be possible to cover more cases here. - if (ime->fieldRef()->numParts() > 1) { - return false; - } - - // We must have an equality to an empty array for this null query to be covered, otherwise, - // because we generate both null and undefined point intervals for a null query, and because - // a multikey index reuses the same entry for [] and undefined, we will not be able to cover - // the query. - if (!ime->hasEmptyArray()) { - return false; - } - } - - return true; -} - -void IndexBoundsBuilder::_mergeTightness(const BoundsTightness& tightness, - BoundsTightness& tightnessOut) { - // There is a special case where we may have a covered null query (EXACT_MAYBE_COVERED) and a - // regex with inexact bounds that doesn't need a FETCH (INEXACT_COVERED). In this case, we want - // to update the tightness to INEXACT_MAYBE_COVERED, to indicate that we need to check if the - // projection allows us to cover the query, but ensure that we will have a filter on the index - // if it turns out we can. - if (((tightness == BoundsTightness::EXACT_MAYBE_COVERED) && - (tightnessOut == BoundsTightness::INEXACT_COVERED)) || - ((tightness == BoundsTightness::INEXACT_COVERED) && - (tightnessOut == BoundsTightness::EXACT_MAYBE_COVERED))) { - tightnessOut = BoundsTightness::INEXACT_MAYBE_COVERED; - } else if (tightness < tightnessOut) { - // Otherwise, fallback to picking the new tightness if it is looser than the old tightness. - tightnessOut = tightness; - } -} - void IndexBoundsBuilder::_translatePredicate(const MatchExpression* expr, const BSONElement& elt, const IndexEntry& index, @@ -1038,45 +955,51 @@ void IndexBoundsBuilder::_translatePredicate(const MatchExpression* expr, }); const InMatchExpression* ime = static_cast<const InMatchExpression*>(expr); + *tightnessOut = IndexBoundsBuilder::EXACT; // Create our various intervals. IndexBoundsBuilder::BoundsTightness tightness; - // We check if the $in predicate satisfies conditions to be a covered null predicate on the - // basis of indexes, null intervals, and array intervals. - const bool entireNullIntervalMatchesPredicate = - detectIfEntireNullIntervalMatchesPredicate(ime, index); + bool arrayOrNullPresent = false; for (auto&& equality : ime->getEqualities()) { - // First, we generate the bounds the same way that we would do for an individual - // equality. This will set tightness to the value it should be if this equality is being - // considered in isolation. - IndexBoundsBuilder::translateEquality(equality, index, isHashed, oilOut, &tightness); - if (entireNullIntervalMatchesPredicate && - (BSONType::jstNULL == equality.type() || - (BSONType::Array == equality.type() && equality.Obj().isEmpty()))) { - // We may have a covered null query. In this case, we update both empty array and - // null interval tightness to EXACT_MAYBE_COVERED, as individually they would have a - // tightness of INEXACT_FETCH. However, we already know we will be able to cover - // these intervals together if we have appropriate projections. Note that any other - // intervals that cannot be covered may still require the query to use a FETCH. - tightness = IndexBoundsBuilder::EXACT_MAYBE_COVERED; + translateEquality(equality, index, isHashed, oilOut, &tightness); + // The ordering invariant of oil has been violated by the call to translateEquality. + arrayOrNullPresent = arrayOrNullPresent || equality.type() == BSONType::jstNULL || + equality.type() == BSONType::Array; + if (tightness != IndexBoundsBuilder::EXACT) { + *tightnessOut = tightness; } - IndexBoundsBuilder::_mergeTightness(tightness, *tightnessOut); } for (auto&& regex : ime->getRegexes()) { translateRegex(regex.get(), index, oilOut, &tightness); - IndexBoundsBuilder::_mergeTightness(tightness, *tightnessOut); + if (tightness != IndexBoundsBuilder::EXACT) { + *tightnessOut = tightness; + } + } + + if (ime->hasNull()) { + // A null index key does not always match a null query value so we must fetch the + // doc and run a full comparison. See SERVER-4529. + // TODO: Do we already set the tightnessOut by calling translateEquality? + *tightnessOut = INEXACT_FETCH; + } + + if (ime->hasEmptyArray()) { + // Empty arrays are indexed as undefined. + BSONObjBuilder undefinedBob; + undefinedBob.appendUndefined(""); + oilOut->intervals.push_back(makePointInterval(undefinedBob.obj())); + *tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; } // Equalities are already sorted and deduped so unionize is unneccesary if no regexes // are present. Hashed indexes may also cause the bounds to be out-of-order. - // Arrays and nulls introduce multiple elements that necessitate a sort and deduping. - if (ime->hasNonScalarOrNonEmptyValues() || index.type == IndexType::INDEX_HASHED) { + // Arrays and nulls introduce multiple elements that neccesitate a sort and deduping. + if (!ime->getRegexes().empty() || index.type == IndexType::INDEX_HASHED || + arrayOrNullPresent) unionize(oilOut); - } - } else if (MatchExpression::GEO == expr->matchType()) { const GeoMatchExpression* gme = static_cast<const GeoMatchExpression*>(expr); if ("2dsphere" == elt.valueStringDataSafe()) { @@ -1392,7 +1315,6 @@ void IndexBoundsBuilder::translateEquality(const BSONElement& data, } std::sort(oil->intervals.begin(), oil->intervals.end(), IntervalComparison); - *tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; } diff --git a/src/mongo/db/query/index_bounds_builder.h b/src/mongo/db/query/index_bounds_builder.h index d1067caa561..b48228328f5 100644 --- a/src/mongo/db/query/index_bounds_builder.h +++ b/src/mongo/db/query/index_bounds_builder.h @@ -67,28 +67,16 @@ public: * increasing tightness. These values are used when we need to do comparison between two * BoundsTightness values. Such comparisons can answer questions such as "Does predicate * X have tighter or looser bounds than predicate Y?". - * - * These enum values are ordered from loosest to tightest. */ enum BoundsTightness { // Index bounds are inexact, and a fetch is required. INEXACT_FETCH = 0, - // Index bounds are inexact, and a fetch may be required depending on the projection. - // For example, a count $in query on null + a regex can be covered, but a find query with - // the same filter and no projection cannot. - INEXACT_MAYBE_COVERED = 1, - - // Index bounds are exact, but a fetch may be required depending on the projection. - // For example, a find query on null may be covered, depending on which fields we project - // out. - EXACT_MAYBE_COVERED = 2, - - // Index bounds are inexact, but no fetch is required. - INEXACT_COVERED = 3, + // Index bounds are inexact, but no fetch is required + INEXACT_COVERED = 1, // Index bounds are exact. - EXACT = 4 + EXACT = 2 }; /** @@ -313,11 +301,6 @@ private: OrderedIntervalList* oilOut, BoundsTightness* tightnessOut, interval_evaluation_tree::Builder* ietBuilder); - - /** - * Helper method for merging interval tightness for $in expressions. - */ - static void _mergeTightness(const BoundsTightness& tightness, BoundsTightness& tightnessOut); }; } // namespace mongo diff --git a/src/mongo/db/query/index_bounds_builder_eq_null_test.cpp b/src/mongo/db/query/index_bounds_builder_eq_null_test.cpp index 31e17b6e2c8..af4cdf91303 100644 --- a/src/mongo/db/query/index_bounds_builder_eq_null_test.cpp +++ b/src/mongo/db/query/index_bounds_builder_eq_null_test.cpp @@ -48,7 +48,7 @@ void assertBoundsRepresentEqualsNull(const OrderedIntervalList& oil) { oil.intervals[1].compare(Interval(fromjson("{'': null, '': null}"), true, true))); } -TEST_F(IndexBoundsBuilderTest, TranslateExprEqualToNullIsExactMaybeCovered) { +TEST_F(IndexBoundsBuilderTest, TranslateExprEqualToNullIsInexactFetch) { BSONObj keyPattern = BSON("a" << 1); BSONElement elt = keyPattern.firstElement(); auto testIndex = buildSimpleIndexEntry(keyPattern); @@ -65,11 +65,11 @@ TEST_F(IndexBoundsBuilderTest, TranslateExprEqualToNullIsExactMaybeCovered) { oil.intervals[0].compare(Interval(fromjson("{'': undefined, '': undefined}"), true, true))); ASSERT_EQUALS(Interval::INTERVAL_EQUALS, oil.intervals[1].compare(Interval(fromjson("{'': null, '': null}"), true, true))); - ASSERT_EQUALS(tightness, IndexBoundsBuilder::EXACT_MAYBE_COVERED); + ASSERT_EQUALS(tightness, IndexBoundsBuilder::INEXACT_FETCH); assertIET(inputParamIdMap, ietBuilder, elt, testIndex, oil); } -TEST_F(IndexBoundsBuilderTest, TranslateEqualsToNullShouldBuildExactMaybeCoveredBounds) { +TEST_F(IndexBoundsBuilderTest, TranslateEqualsToNullShouldBuildInexactBounds) { BSONObj indexPattern = BSON("a" << 1); auto testIndex = buildSimpleIndexEntry(indexPattern); @@ -83,12 +83,12 @@ TEST_F(IndexBoundsBuilderTest, TranslateEqualsToNullShouldBuildExactMaybeCovered expr.get(), indexPattern.firstElement(), testIndex, &oil, &tightness, &ietBuilder); ASSERT_EQUALS(oil.name, "a"); - ASSERT_EQUALS(tightness, IndexBoundsBuilder::EXACT_MAYBE_COVERED); + ASSERT_EQUALS(tightness, IndexBoundsBuilder::INEXACT_FETCH); assertBoundsRepresentEqualsNull(oil); assertIET(inputParamIdMap, ietBuilder, indexPattern.firstElement(), testIndex, oil); } -TEST_F(IndexBoundsBuilderTest, TranslateDottedEqualsToNullShouldBuildExactMaybeCoveredBounds) { +TEST_F(IndexBoundsBuilderTest, TranslateDottedEqualsToNullShouldBuildInexactBounds) { BSONObj indexPattern = BSON("a.b" << 1); auto testIndex = buildSimpleIndexEntry(indexPattern); @@ -102,9 +102,7 @@ TEST_F(IndexBoundsBuilderTest, TranslateDottedEqualsToNullShouldBuildExactMaybeC expr.get(), indexPattern.firstElement(), testIndex, &oil, &tightness, &ietBuilder); ASSERT_EQUALS(oil.name, "a.b"); - // Depending on the query projection, this will either be converted to EXACT or to INEXACT_FETCH - // before we build an IXSCAN plan. - ASSERT_EQUALS(tightness, IndexBoundsBuilder::EXACT_MAYBE_COVERED); + ASSERT_EQUALS(tightness, IndexBoundsBuilder::INEXACT_FETCH); assertBoundsRepresentEqualsNull(oil); assertIET(inputParamIdMap, ietBuilder, indexPattern.firstElement(), testIndex, oil); } diff --git a/src/mongo/db/query/index_tag.cpp b/src/mongo/db/query/index_tag.cpp index ab5acea4de0..29c450d6ae2 100644 --- a/src/mongo/db/query/index_tag.cpp +++ b/src/mongo/db/query/index_tag.cpp @@ -120,33 +120,21 @@ void sortUsingTags(MatchExpression* tree) { }); } -/** - * Attaches 'node' to 'target'. If 'target' is an AND, adds 'node' as a child of 'target'. - * Otherwise, creates an AND that is a child of 'targetParent' at position 'targetPosition', and - * adds 'target' and 'node' as its children. Tags 'node' with 'tagData'. If 'node' appears as a key - * in 'pathsToUpdate', then we set the new path onto the clone. - */ +// Attaches 'node' to 'target'. If 'target' is an AND, adds 'node' as a child of 'target'. +// Otherwise, creates an AND that is a child of 'targetParent' at position 'targetPosition', and +// adds 'target' and 'node' as its children. Tags 'node' with 'tagData'. void attachNode(MatchExpression* node, MatchExpression* target, OrMatchExpression* targetParent, size_t targetPosition, - std::unique_ptr<MatchExpression::TagData> tagData, - const stdx::unordered_map<MatchExpression*, FieldRef>& pathsToUpdate) { + std::unique_ptr<MatchExpression::TagData> tagData) { auto clone = node->shallowClone(); if (clone->matchType() == MatchExpression::NOT) { IndexTag* indexTag = static_cast<IndexTag*>(tagData.get()); clone->setTag(new IndexTag(indexTag->index)); clone->getChild(0)->setTag(tagData.release()); - - if (auto it = pathsToUpdate.find(node->getChild(0)); it != pathsToUpdate.end()) { - checked_cast<PathMatchExpression*>(clone->getChild(0)) - ->setPath(it->second.dottedField()); - } } else { clone->setTag(tagData.release()); - if (auto it = pathsToUpdate.find(node); it != pathsToUpdate.end()) { - checked_cast<PathMatchExpression*>(clone.get())->setPath(it->second.dottedField()); - } } if (MatchExpression::AND == target->matchType()) { @@ -176,24 +164,17 @@ stdx::unordered_map<size_t, std::vector<OrPushdownTag::Destination>> partitionCh return childDestinations; } -/** - * Finds the node within 'tree' that is an indexed OR, if one exists. It also returns the subpath in - * which the indexed OR lives. - */ -std::pair<MatchExpression*, FieldRef> getIndexedOr(FieldRef currentPath, MatchExpression* tree) { +// Finds the node within 'tree' that is an indexed OR, if one exists. +MatchExpression* getIndexedOr(MatchExpression* tree) { if (MatchExpression::OR == tree->matchType() && tree->getTag()) { - return {tree, std::move(currentPath)}; - } - if (const auto* fieldRef = tree->fieldRef()) { - currentPath = currentPath + *fieldRef; + return tree; } - for (size_t i = 0; i < tree->numChildren(); ++i) { - if (auto result = getIndexedOr(currentPath, tree->getChild(i)); result.first) { - return result; + if (auto indexedOrChild = getIndexedOr(tree->getChild(i))) { + return indexedOrChild; } } - return {}; + return nullptr; } // Pushes down 'node' along the routes in 'target' specified in 'destinations'. Each value in the @@ -201,8 +182,7 @@ std::pair<MatchExpression*, FieldRef> getIndexedOr(FieldRef currentPath, MatchEx // descendant of 'target'. bool pushdownNode(MatchExpression* node, MatchExpression* target, - std::vector<OrPushdownTag::Destination> destinations, - const stdx::unordered_map<MatchExpression*, FieldRef>& pathsToUpdate) { + std::vector<OrPushdownTag::Destination> destinations) { if (MatchExpression::OR == target->matchType()) { OrMatchExpression* orNode = static_cast<OrMatchExpression*>(target); bool moveToAllChildren = true; @@ -226,15 +206,13 @@ bool pushdownNode(MatchExpression* node, orNode->getChild(i), orNode, i, - std::move(childDestinations->second[0].tagData), - pathsToUpdate); + std::move(childDestinations->second[0].tagData)); } else { // This child was specified by a non-trivial route in destinations, so we recur. moveToAllChildren = pushdownNode(node, orNode->getChild(i), - std::move(childDestinations->second), - pathsToUpdate) && + std::move(childDestinations->second)) && moveToAllChildren; } } @@ -243,81 +221,36 @@ bool pushdownNode(MatchExpression* node, } if (MatchExpression::AND == target->matchType()) { - auto [indexedOr, fieldRef_unused] = getIndexedOr({} /*fieldRef*/, target); + auto indexedOr = getIndexedOr(target); invariant(indexedOr); - return pushdownNode(node, indexedOr, std::move(destinations), pathsToUpdate); + return pushdownNode(node, indexedOr, std::move(destinations)); } MONGO_UNREACHABLE_TASSERT(4457014); } -/** - * Populates 'out' with all descendants of 'node' that have OrPushdownTags, assuming the initial - * input is an ELEM_MATCH_OBJECT. The "currentPath" argument is the combined path traversed so far. - * Additionally, we populate a map to keep track of paths to update afterward during cloning. - */ -void getElemMatchOrPushdownDescendants( - const FieldRef& indexedOrPath, - FieldRef currentPath, - MatchExpression* node, - std::vector<MatchExpression*>* out, - stdx::unordered_map<MatchExpression*, FieldRef>* pathsToUpdate) { - const bool updatePath = node->fieldRef() != nullptr; - if (updatePath) { - currentPath = currentPath + *node->fieldRef(); - } - - // Do not do extra pushdown of OR inside $elemmatch. +// Populates 'out' with all descendants of 'node' that have OrPushdownTags, assuming the initial +// input is an ELEM_MATCH_OBJECT. +void getElemMatchOrPushdownDescendants(MatchExpression* node, std::vector<MatchExpression*>* out) { if (node->getTag() && node->getTag()->getType() == TagType::OrPushdownTag) { - if (updatePath) { - // Make sure that we remove the common prefix between the "destination" OR and the - // current expression, as it may be contained within the same $elemmatch. - - const auto prefixSize = indexedOrPath.commonPrefixSize(currentPath); - for (auto i = 0; i < prefixSize; i++) { - currentPath.removeFirstPart(); - } - if (currentPath != *node->fieldRef()) { - pathsToUpdate->emplace(node, std::move(currentPath)); - } - } out->push_back(node); } else if (node->matchType() == MatchExpression::ELEM_MATCH_OBJECT || node->matchType() == MatchExpression::AND) { for (size_t i = 0; i < node->numChildren(); ++i) { - getElemMatchOrPushdownDescendants( - indexedOrPath, currentPath, node->getChild(i), out, pathsToUpdate); + getElemMatchOrPushdownDescendants(node->getChild(i), out); } } else if (node->matchType() == MatchExpression::NOT) { // The immediate child of NOT may be tagged, but there should be no tags deeper than this. auto* childNode = node->getChild(0); if (childNode->getTag() && childNode->getTag()->getType() == TagType::OrPushdownTag) { - if (!childNode->path().empty()) { - // Make sure that we remove the common prefix between the "destination" OR and the - // current expression, as it may be contained within the same $elemmatch. - - currentPath = currentPath + *childNode->fieldRef(); - const auto prefixSize = indexedOrPath.commonPrefixSize(currentPath); - for (auto i = 0; i < prefixSize; i++) { - currentPath.removeFirstPart(); - } - if (currentPath != *childNode->fieldRef()) { - pathsToUpdate->emplace(childNode, std::move(currentPath)); - } - } out->push_back(node); } } } -/** - * Attempts to push the given node down into the 'indexedOr' subtree. Returns true if the predicate - * can subsequently be trimmed from the MatchExpression tree, false otherwise. Also supplied is a - * map to optionally update the path of the 'node' being pushed down. - */ -bool processOrPushdownNode(MatchExpression* node, - MatchExpression* indexedOr, - const stdx::unordered_map<MatchExpression*, FieldRef>& pathsToUpdate) { +// Attempts to push the given node down into the 'indexedOr' subtree. Returns true if the predicate +// can subsequently be trimmed from the MatchExpression tree, false otherwise. +bool processOrPushdownNode(MatchExpression* node, MatchExpression* indexedOr) { // If the node is a negation, then its child is the predicate node that may be tagged. auto* predNode = node->matchType() == MatchExpression::NOT ? node->getChild(0) : node; @@ -334,7 +267,7 @@ bool processOrPushdownNode(MatchExpression* node, predNode->setTag(nullptr); // Attempt to push the node into the indexedOr, then re-set its tag to the indexTag. - const bool pushedDown = pushdownNode(node, indexedOr, std::move(destinations), pathsToUpdate); + const bool pushedDown = pushdownNode(node, indexedOr, std::move(destinations)); predNode->setTag(indexTag.release()); // Return true if we can trim the predicate. We could trim the node even if it had an index tag @@ -351,26 +284,20 @@ void resolveOrPushdowns(MatchExpression* tree) { } if (MatchExpression::AND == tree->matchType()) { AndMatchExpression* andNode = static_cast<AndMatchExpression*>(tree); - auto [indexedOr, indexedOrPath] = getIndexedOr({} /*fieldRef*/, andNode); + MatchExpression* indexedOr = getIndexedOr(andNode); for (size_t i = 0; i < andNode->numChildren(); ++i) { auto child = andNode->getChild(i); - // For ELEM_MATCH_OBJECT, we push down all tagged descendants. However, we cannot - // trim any of these predicates, since the $elemMatch filter must be applied in its - // entirety. + // For ELEM_MATCH_OBJECT, we push down all tagged descendants. However, we cannot trim + // any of these predicates, since the $elemMatch filter must be applied in its entirety. if (child->matchType() == MatchExpression::ELEM_MATCH_OBJECT) { std::vector<MatchExpression*> orPushdownDescendants; - stdx::unordered_map<MatchExpression*, FieldRef> pathsToUpdate; - getElemMatchOrPushdownDescendants(indexedOrPath, - {} /*currentPath*/, - child, - &orPushdownDescendants, - &pathsToUpdate); + getElemMatchOrPushdownDescendants(child, &orPushdownDescendants); for (auto descendant : orPushdownDescendants) { - static_cast<void>(processOrPushdownNode(descendant, indexedOr, pathsToUpdate)); + static_cast<void>(processOrPushdownNode(descendant, indexedOr)); } - } else if (processOrPushdownNode(child, indexedOr, {} /*pathsToUpdate*/)) { + } else if (processOrPushdownNode(child, indexedOr)) { // The indexed $or can completely satisfy the child predicate, so we trim it. auto ownedChild = andNode->removeChild(i); --i; diff --git a/src/mongo/db/query/indexability.h b/src/mongo/db/query/indexability.h index 1736d92a89b..7e543da4a2d 100644 --- a/src/mongo/db/query/indexability.h +++ b/src/mongo/db/query/indexability.h @@ -55,26 +55,6 @@ public: } /** - * Type bracketing does not apply to internal Expressions. This could cause the use of a sparse - * index return incomplete results. For example, a query {$expr: {$lt: ["$missing", "r"]}} would - * expect a document like, {a: 1}, with field "missing" missing be returned. However, a sparse - * index, {missing: 1} does not index the document. Therefore, we should ban use of any sparse - * index on following expression types. - */ - static bool nodeSupportedBySparseIndex(const MatchExpression* me) { - switch (me->matchType()) { - case MatchExpression::INTERNAL_EXPR_EQ: - case MatchExpression::INTERNAL_EXPR_GT: - case MatchExpression::INTERNAL_EXPR_GTE: - case MatchExpression::INTERNAL_EXPR_LT: - case MatchExpression::INTERNAL_EXPR_LTE: - return false; - default: - return true; - } - } - - /** * This array operator doesn't have any children with fields and can use an index. * * Example: a: {$elemMatch: {$gte: 1, $lte: 1}}. @@ -136,20 +116,6 @@ public: } /** - * Returns true if 'me' is ELEM_MATCH_OBJECT and has non-empty path component. - * - * Note: we skip empty path components since they are not allowed in index key patterns. - * Therefore, $elemMatch with an empty path component can never use an index. - * - * Example: {"": {$elemMatch: {a: "hi", b: "bye"}}. - * In this case the predicate cannot use any indexes since the $elemMatch is with an empty path - * component. - */ - static bool isBoundsGeneratingElemMatchObject(const MatchExpression* me) { - return arrayUsesIndexOnChildren(me) && !me->path().empty(); - } - - /** * Returns true if 'me' is a NOT, and the child of the NOT can use * an index on its own field. */ diff --git a/src/mongo/db/query/internal_plans.cpp b/src/mongo/db/query/internal_plans.cpp index 78820eb8111..04f70b1d2cc 100644 --- a/src/mongo/db/query/internal_plans.cpp +++ b/src/mongo/db/query/internal_plans.cpp @@ -123,8 +123,7 @@ CollectionScanParams createCollectionScanParams( boost::optional<RecordId> resumeAfterRecordId, boost::optional<RecordIdBound> minRecord, boost::optional<RecordIdBound> maxRecord, - CollectionScanParams::ScanBoundInclusion boundInclusion, - bool shouldReturnEofOnFilterMismatch) { + CollectionScanParams::ScanBoundInclusion boundInclusion) { const auto& collection = *coll; invariant(collection); @@ -140,7 +139,6 @@ CollectionScanParams createCollectionScanParams( params.direction = CollectionScanParams::BACKWARD; } params.boundInclusion = boundInclusion; - params.shouldReturnEofOnFilterMismatch = shouldReturnEofOnFilterMismatch; return params; } } // namespace @@ -153,8 +151,7 @@ std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> InternalPlanner::collection boost::optional<RecordId> resumeAfterRecordId, boost::optional<RecordIdBound> minRecord, boost::optional<RecordIdBound> maxRecord, - CollectionScanParams::ScanBoundInclusion boundInclusion, - bool shouldReturnEofOnFilterMismatch) { + CollectionScanParams::ScanBoundInclusion boundInclusion) { const auto& collection = *coll; invariant(collection); @@ -170,8 +167,7 @@ std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> InternalPlanner::collection resumeAfterRecordId, minRecord, maxRecord, - boundInclusion, - shouldReturnEofOnFilterMismatch); + boundInclusion); auto cs = _collectionScan(expCtx, ws.get(), &collection, collScanParams); @@ -222,19 +218,11 @@ std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> InternalPlanner::deleteWith boost::optional<RecordIdBound> minRecord, boost::optional<RecordIdBound> maxRecord, CollectionScanParams::ScanBoundInclusion boundInclusion, - std::unique_ptr<BatchedDeleteStageBatchParams> batchedDeleteParams, - const MatchExpression* filter, - bool shouldReturnEofOnFilterMismatch) { + boost::optional<std::unique_ptr<BatchedDeleteStageBatchParams>> batchParams) { const auto& collection = *coll; invariant(collection); - if (shouldReturnEofOnFilterMismatch) { - tassert(7010801, - "MatchExpression filter must be provided when 'shouldReturnEofOnFilterMismatch' is " - "set to true ", - filter); - } - auto ws = std::make_unique<WorkingSet>(); + auto expCtx = make_intrusive<ExpressionContext>( opCtx, std::unique_ptr<CollatorInterface>(nullptr), collection->ns()); @@ -249,15 +237,14 @@ std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> InternalPlanner::deleteWith boost::none /* resumeAfterId */, minRecord, maxRecord, - boundInclusion, - shouldReturnEofOnFilterMismatch); + boundInclusion); - auto root = _collectionScan(expCtx, ws.get(), &collection, collScanParams, filter); + auto root = _collectionScan(expCtx, ws.get(), &collection, collScanParams); - if (batchedDeleteParams) { + if (batchParams) { root = std::make_unique<BatchedDeleteStage>(expCtx.get(), std::move(params), - std::move(batchedDeleteParams), + std::move(*batchParams), ws.get(), collection, root.release()); @@ -467,13 +454,12 @@ std::unique_ptr<PlanStage> InternalPlanner::_collectionScan( const boost::intrusive_ptr<ExpressionContext>& expCtx, WorkingSet* ws, const CollectionPtr* coll, - const CollectionScanParams& params, - const MatchExpression* filter) { + const CollectionScanParams& params) { const auto& collection = *coll; invariant(collection); - return std::make_unique<CollectionScan>(expCtx.get(), collection, params, ws, filter); + return std::make_unique<CollectionScan>(expCtx.get(), collection, params, ws, nullptr); } std::unique_ptr<PlanStage> InternalPlanner::_indexScan( diff --git a/src/mongo/db/query/internal_plans.h b/src/mongo/db/query/internal_plans.h index 46400c4e3fa..ea8de7c0042 100644 --- a/src/mongo/db/query/internal_plans.h +++ b/src/mongo/db/query/internal_plans.h @@ -83,8 +83,7 @@ public: boost::optional<RecordIdBound> minRecord = boost::none, boost::optional<RecordIdBound> maxRecord = boost::none, CollectionScanParams::ScanBoundInclusion boundInclusion = - CollectionScanParams::ScanBoundInclusion::kIncludeBothStartAndEndRecords, - bool shouldReturnEofOnFilterMismatch = false); + CollectionScanParams::ScanBoundInclusion::kIncludeBothStartAndEndRecords); static std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> collectionScan( OperationContext* opCtx, @@ -105,9 +104,7 @@ public: boost::optional<RecordIdBound> maxRecord = boost::none, CollectionScanParams::ScanBoundInclusion boundInclusion = CollectionScanParams::ScanBoundInclusion::kIncludeBothStartAndEndRecords, - std::unique_ptr<BatchedDeleteStageBatchParams> batchedDeleteParams = nullptr, - const MatchExpression* filter = nullptr, - bool shouldReturnEofOnFilterMismatch = false); + boost::optional<std::unique_ptr<BatchedDeleteStageBatchParams>> batchParams = boost::none); /** * Returns an index scan. Caller owns returned pointer. @@ -200,8 +197,7 @@ private: const boost::intrusive_ptr<ExpressionContext>& expCtx, WorkingSet* ws, const CollectionPtr* collection, - const CollectionScanParams& params, - const MatchExpression* filter = nullptr); + const CollectionScanParams& params); /** * Returns a plan stage that is either an index scan or an index scan with a fetch stage. diff --git a/src/mongo/db/query/lru_key_value.h b/src/mongo/db/query/lru_key_value.h index 2786e1c40ab..88186c70923 100644 --- a/src/mongo/db/query/lru_key_value.h +++ b/src/mongo/db/query/lru_key_value.h @@ -28,6 +28,7 @@ */ #pragma once + #include <fmt/format.h> #include <list> #include <memory> @@ -39,56 +40,30 @@ namespace mongo { /** - * 'InsertionEvictionListener' class to use with 'LRUBudgetTracker' that will always noop. - */ -class NoopInsertionEvictionListener { -public: - // Called when a key-value pair is being inserted. Parameters are the key-value pair and its - // estimated size. - template <class K, class V> - void onInsert(const K&, const V&, size_t) {} - - // Called when a key-value pair is being evicted. Parameters are the key-value pair and its - // estimated size. - template <class K, class V> - void onEvict(const K&, const V&, size_t) {} - - // Called when the cache is being cleared. Parameter is the estimated size of the key-value - // pairs in the cache before it was cleared. - void onClear(size_t) {} -}; - -/** * This class tracks a size of entries in 'LRUKeyValue'. * The size can be understood as a number of the entries, an amount of memory they occupied, * or any other value defined by the template parameter 'Estimator'. * The 'Estimator' must be deterministic and always return the same value for the same entry. - * The 'InsertionEvictionListener' will be called on every insertion and eviction as well as when - * the cache is cleared. */ -template <class K, class V, typename Estimator, typename InsertionEvictionListener> +template <typename V, typename Estimator> class LRUBudgetTracker { public: LRUBudgetTracker(size_t maxBudget) : _max(maxBudget), _current(0) {} - void onAdd(const K& k, const V& v) { - size_t budget = _estimator(k, v); - _current += budget; - _listener.onInsert(k, v, budget); + void onAdd(const V& v) { + _current += _estimator(v); } - void onRemove(const K& k, const V& v) { + void onRemove(const V& v) { using namespace fmt::literals; - size_t budget = _estimator(k, v); + size_t budget = _estimator(v); tassert(5968300, "LRU budget underflow: current={}, budget={} "_format(_current, budget), _current >= budget); _current -= budget; - _listener.onEvict(k, v, budget); } void onClear() { - _listener.onClear(_current); _current = 0; } @@ -109,7 +84,6 @@ private: size_t _max; size_t _current; Estimator _estimator; - InsertionEvictionListener _listener; }; /** @@ -117,9 +91,6 @@ private: * policy. The size allowed in the kv-store is controlled by 'LRUBudgetTracker' * set in the constructor. * - * An 'InsertionEvictionListener' may optionally be specified to track the insertion and eviction of - * each key-value pair. - * * Caveat: * This kv-store is NOT thread safe! The client to this utility is responsible * for protecting concurrent access to the LRU store if used in a threaded @@ -131,12 +102,7 @@ private: * TODO: We could move this into the util/ directory and do any cleanup necessary to make it * fully general. */ -template <class K, - class V, - class KeyValueBudgetEstimator, - class InsertionEvictionListener = NoopInsertionEvictionListener, - class KeyHasher = std::hash<K>, - class Eq = std::equal_to<K>> +template <class K, class V, class BudgetEstimator, class KeyHasher = std::hash<K>> class LRUKeyValue { public: LRUKeyValue(size_t maxSize) : _budgetTracker{maxSize} {} @@ -145,13 +111,13 @@ public: clear(); } - typedef std::pair<const K*, V> KVListEntry; + typedef std::pair<K, V> KVListEntry; typedef std::list<KVListEntry> KVList; typedef typename KVList::iterator KVListIt; typedef typename KVList::const_iterator KVListConstIt; - typedef stdx::unordered_map<K, KVListIt, KeyHasher, Eq> KVMap; + typedef stdx::unordered_map<K, KVListIt, KeyHasher> KVMap; typedef typename KVMap::const_iterator KVMapConstIt; // These type declarations are required by the 'Partitioned' utility. @@ -170,15 +136,14 @@ public: KVMapConstIt i = _kvMap.find(key); if (i != _kvMap.end()) { KVListIt found = i->second; - _budgetTracker.onRemove(key, found->second); + _budgetTracker.onRemove(found->second); _kvMap.erase(i); _kvList.erase(found); } - _budgetTracker.onAdd(key, entry); - _kvList.push_front(std::make_pair(nullptr, std::move(entry))); + _budgetTracker.onAdd(entry); + _kvList.push_front(std::make_pair(key, std::move(entry))); _kvMap[key] = _kvList.begin(); - _kvList.begin()->first = &(_kvMap.find(key)->first); return evict(); } @@ -196,11 +161,10 @@ public: KVListIt found = i->second; // Promote the kv-store entry to the front of the list. It is now the most recently used. - _kvList.push_front(std::make_pair(nullptr, std::move(found->second))); + _kvList.push_front(std::make_pair(key, std::move(found->second))); _kvMap.erase(i); _kvList.erase(found); _kvMap[key] = _kvList.begin(); - _kvList.begin()->first = &(_kvMap.find(key)->first); return _kvList.begin(); } @@ -215,7 +179,7 @@ public: return false; } KVListIt found = i->second; - _budgetTracker.onRemove(key, found->second); + _budgetTracker.onRemove(found->second); _kvMap.erase(i); _kvList.erase(found); return true; @@ -229,9 +193,9 @@ public: size_t removeIf(KeyValuePredicate predicate) { size_t removed = 0; for (auto it = _kvList.begin(); it != _kvList.end();) { - if (predicate(*it->first, *it->second)) { - _budgetTracker.onRemove(*it->first, it->second); - _kvMap.erase(*it->first); + if (predicate(it->first, *it->second)) { + _budgetTracker.onRemove(it->second); + _kvMap.erase(it->first); it = _kvList.erase(it); ++removed; } else { @@ -245,9 +209,9 @@ public: * Deletes all entries in the kv-store. */ void clear() { + _budgetTracker.onClear(); _kvList.clear(); _kvMap.clear(); - _budgetTracker.onClear(); } /** @@ -294,8 +258,8 @@ private: while (_budgetTracker.isOverBudget()) { invariant(!_kvList.empty()); - _budgetTracker.onRemove(*_kvList.back().first, _kvList.back().second); - _kvMap.erase(*_kvList.back().first); + _budgetTracker.onRemove(_kvList.back().second); + _kvMap.erase(_kvList.back().first); _kvList.pop_back(); ++nEvicted; @@ -304,14 +268,13 @@ private: return nEvicted; } - LRUBudgetTracker<K, V, KeyValueBudgetEstimator, InsertionEvictionListener> _budgetTracker; + LRUBudgetTracker<V, BudgetEstimator> _budgetTracker; // (K, V) pairs are stored in this std::list. They are sorted in order of use, where the front // is the most recently used and the back is the least recently used. mutable KVList _kvList; // Maps from a key to the corresponding std::list entry. - // TODO: SERVER-73659 LRUKeyValue should track and include the size of _kvMap in overall budget. mutable KVMap _kvMap; }; diff --git a/src/mongo/db/query/lru_key_value_test.cpp b/src/mongo/db/query/lru_key_value_test.cpp index 6dcdfc5a4ea..3ebf47267fb 100644 --- a/src/mongo/db/query/lru_key_value_test.cpp +++ b/src/mongo/db/query/lru_key_value_test.cpp @@ -64,15 +64,15 @@ struct ValueType { struct TrivialBudgetEstimator { static constexpr size_t kSize = 1; - size_t operator()(const int&, const ValueType&) { + size_t operator()(const ValueType&) { return kSize; } - size_t operator()(const int&, const std::unique_ptr<int>&) { + size_t operator()(const std::shared_ptr<int>&) { return kSize; } - size_t operator()(const int&, const std::shared_ptr<int>) { + size_t operator()(const std::unique_ptr<int>&) { return kSize; } }; @@ -87,7 +87,7 @@ struct NonTrivialEntry { }; struct NonTrivialBudgetEstimator { - size_t operator()(const int& key, const std::shared_ptr<NonTrivialEntry> value) { + size_t operator()(const std::shared_ptr<NonTrivialEntry>& value) { return value->budgetSize; } }; @@ -95,40 +95,8 @@ struct NonTrivialBudgetEstimator { using NonTrivialTestSharedPtrValue = LRUKeyValue<size_t, std::shared_ptr<NonTrivialEntry>, NonTrivialBudgetEstimator>; -class NonTrivialInsertionEvictionListener { -public: - NonTrivialInsertionEvictionListener() { - keyTotal = 0; - valueTotal = 0; - budgetTotal = 0; - } - - void onInsert(const int& k, const ValueType& v, size_t budget) { - keyTotal += k; - valueTotal += v.val; - budgetTotal += budget; - } - - void onEvict(const int& k, const ValueType& v, size_t budget) { - keyTotal -= k; - valueTotal -= v.val; - budgetTotal -= budget; - } - - void onClear(size_t budget) { - budgetTotal -= budget; - } - - static size_t keyTotal; - static size_t valueTotal; - static size_t budgetTotal; -}; -size_t NonTrivialInsertionEvictionListener::keyTotal; -size_t NonTrivialInsertionEvictionListener::valueTotal; -size_t NonTrivialInsertionEvictionListener::budgetTotal; - -template <typename Key, typename Value, typename Estimator, typename Listener> -void assertInKVStore(LRUKeyValue<Key, Value, Estimator, Listener>& cache, Key key, Value value) { +template <typename Key, typename Value, typename Estimator> +void assertInKVStore(LRUKeyValue<Key, Value, Estimator>& cache, Key key, Value value) { ASSERT_TRUE(cache.hasKey(key)); auto s = cache.get(key); ASSERT(s.isOK()); @@ -137,8 +105,8 @@ void assertInKVStore(LRUKeyValue<Key, Value, Estimator, Listener>& cache, Key ke ASSERT_EQUALS(*(kvItr->second), *value); } -template <typename Key, typename Value, typename Estimator, typename Listener> -void assertNotInKVStore(LRUKeyValue<Key, Value, Estimator, Listener>& cache, Key key) { +template <typename Key, typename Value, typename Estimator> +void assertNotInKVStore(LRUKeyValue<Key, Value, Estimator>& cache, Key key) { ASSERT_FALSE(cache.hasKey(key)); auto s = cache.get(key); ASSERT(!s.isOK()); @@ -327,10 +295,10 @@ TEST(LRUKeyValueTest, IterationTest) { cache.add(2, std::make_shared<int>(2)); auto i = cache.begin(); - ASSERT_EQUALS(*i->first, 2); + ASSERT_EQUALS(i->first, 2); ASSERT_EQUALS(*i->second, 2); ++i; - ASSERT_EQUALS(*i->first, 1); + ASSERT_EQUALS(i->first, 1); ASSERT_EQUALS(*i->second, 1); ++i; ASSERT(i == cache.end()); @@ -388,8 +356,7 @@ TEST(LRUKeyValueTest, UniquePtrKeyValue) { assertNotInKVStore(cacheForEviction, 1); // The entry with key '1' has been Evicted. } -using TestScalarValue = - LRUKeyValue<int, ValueType, TrivialBudgetEstimator, NonTrivialInsertionEvictionListener>; +using TestScalarValue = LRUKeyValue<int, ValueType, TrivialBudgetEstimator>; void assertValueInKVStore(TestScalarValue& cache, int key, ValueType value) { ASSERT_TRUE(cache.hasKey(key)); @@ -406,17 +373,9 @@ TEST(LRUKeyValueTest, ScalarKeyValue) { assertValueInKVStore(cache, 1, ValueType{2}); assertNotInKVStore(cache, 3); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::keyTotal, 1); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::valueTotal, 2); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::budgetTotal, 1); - cache.add(1, ValueType{3}); assertValueInKVStore(cache, 1, ValueType{3}); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::keyTotal, 1); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::valueTotal, 3); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::budgetTotal, 1); - // Test eviction. TestScalarValue cacheForEviction{2}; cacheForEviction.add(1, ValueType{1}); @@ -425,18 +384,6 @@ TEST(LRUKeyValueTest, ScalarKeyValue) { ASSERT_EQUALS(cacheForEviction.size(), static_cast<size_t>(2)); assertNotInKVStore(cacheForEviction, 1); // The entry with key '1' has been Evicted. - - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::keyTotal, 5); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::valueTotal, 5); - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::budgetTotal, 2); - - // Clear the remaining values. - cacheForEviction.clear(); - - assertNotInKVStore(cacheForEviction, 2); // The entry with key '2' has been Evicted. - assertNotInKVStore(cacheForEviction, 3); // The entry with key '3' has been Evicted. - - ASSERT_EQUALS(NonTrivialInsertionEvictionListener::budgetTotal, 0); } } // namespace diff --git a/src/mongo/db/query/mock_yield_policies.h b/src/mongo/db/query/mock_yield_policies.h index 5774c24fd6e..fa2cee9fbba 100644 --- a/src/mongo/db/query/mock_yield_policies.h +++ b/src/mongo/db/query/mock_yield_policies.h @@ -39,10 +39,8 @@ namespace mongo { */ class MockYieldPolicy : public PlanYieldPolicy { public: - MockYieldPolicy(OperationContext* opCtx, - ClockSource* clockSource, - PlanYieldPolicy::YieldPolicy policy) - : PlanYieldPolicy(opCtx, policy, clockSource, 0, Milliseconds{0}, nullptr, nullptr) {} + MockYieldPolicy(ClockSource* clockSource, PlanYieldPolicy::YieldPolicy policy) + : PlanYieldPolicy(policy, clockSource, 0, Milliseconds{0}, nullptr, nullptr) {} private: void saveState(OperationContext* opCtx) override final { @@ -60,8 +58,8 @@ private: */ class AlwaysTimeOutYieldPolicy final : public MockYieldPolicy { public: - AlwaysTimeOutYieldPolicy(OperationContext* opCtx, ClockSource* cs) - : MockYieldPolicy(opCtx, cs, PlanYieldPolicy::YieldPolicy::ALWAYS_TIME_OUT) {} + AlwaysTimeOutYieldPolicy(ClockSource* cs) + : MockYieldPolicy(cs, PlanYieldPolicy::YieldPolicy::ALWAYS_TIME_OUT) {} bool shouldYieldOrInterrupt(OperationContext*) override { return true; @@ -78,8 +76,8 @@ public: */ class AlwaysPlanKilledYieldPolicy final : public MockYieldPolicy { public: - AlwaysPlanKilledYieldPolicy(OperationContext* opCtx, ClockSource* cs) - : MockYieldPolicy(opCtx, cs, PlanYieldPolicy::YieldPolicy::ALWAYS_MARK_KILLED) {} + AlwaysPlanKilledYieldPolicy(ClockSource* cs) + : MockYieldPolicy(cs, PlanYieldPolicy::YieldPolicy::ALWAYS_MARK_KILLED) {} bool shouldYieldOrInterrupt(OperationContext*) override { return true; @@ -96,8 +94,8 @@ public: */ class NoopYieldPolicy final : public MockYieldPolicy { public: - NoopYieldPolicy(OperationContext* opCtx, ClockSource* clockSource) - : MockYieldPolicy(opCtx, clockSource, PlanYieldPolicy::YieldPolicy::NO_YIELD) {} + NoopYieldPolicy(ClockSource* clockSource) + : MockYieldPolicy(clockSource, PlanYieldPolicy::YieldPolicy::NO_YIELD) {} bool shouldYieldOrInterrupt(OperationContext*) override { return false; diff --git a/src/mongo/db/query/multiple_collection_accessor.h b/src/mongo/db/query/multiple_collection_accessor.h index 9d302ce2b28..26fc081000e 100644 --- a/src/mongo/db/query/multiple_collection_accessor.h +++ b/src/mongo/db/query/multiple_collection_accessor.h @@ -101,17 +101,6 @@ public: _secondaryColls.clear(); } - void forEach(std::function<void(const CollectionPtr&)> func) const { - if (hasMainCollection()) { - func(getMainCollection()); - } - for (const auto& [name, coll] : getSecondaryCollections()) { - if (coll) { - func(coll); - } - } - } - private: const CollectionPtr* _mainColl{&CollectionPtr::null}; diff --git a/src/mongo/db/query/parsed_find_command.cpp b/src/mongo/db/query/parsed_find_command.cpp deleted file mode 100644 index 2ef2e955c06..00000000000 --- a/src/mongo/db/query/parsed_find_command.cpp +++ /dev/null @@ -1,381 +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 "mongo/db/query/parsed_find_command.h" - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -#include "mongo/db/cst/cst_parser.h" -#include "mongo/db/query/collation/collator_factory_interface.h" -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/projection_parser.h" -#include "mongo/db/query/query_planner_common.h" -#include "mongo/db/query/query_request_helper.h" -#include "mongo/logv2/log.h" - -namespace mongo { - -namespace { -/** - * Does 'root' have a subtree of type 'subtreeType' with a node of type 'childType' inside? - */ -bool hasNodeInSubtree(const MatchExpression* root, - MatchExpression::MatchType childType, - MatchExpression::MatchType subtreeType) { - if (subtreeType == root->matchType()) { - return QueryPlannerCommon::hasNode(root, childType); - } - for (size_t i = 0; i < root->numChildren(); ++i) { - if (hasNodeInSubtree(root->getChild(i), childType, subtreeType)) { - return true; - } - } - return false; -} - -bool parsingCanProduceNoopMatchNodes(const ExtensionsCallback& extensionsCallback, - MatchExpressionParser::AllowedFeatureSet allowedFeatures) { - return extensionsCallback.hasNoopExtensions() && - (allowedFeatures & MatchExpressionParser::AllowedFeatures::kText || - allowedFeatures & MatchExpressionParser::AllowedFeatures::kJavascript); -} - -} // namespace - -std::unique_ptr<CollatorInterface> resolveCollator( - OperationContext* opCtx, const std::unique_ptr<FindCommandRequest>& findCommand) { - if (!findCommand->getCollation().isEmpty()) { - return uassertStatusOKWithContext(CollatorFactoryInterface::get(opCtx->getServiceContext()) - ->makeFromBSON(findCommand->getCollation()), - "unable to parse collation"); - } - return nullptr; -} - -/** - * Helper for building 'out.' If there is a projection, parse it and add any metadata dependencies - * it induces. - * - * Throws exceptions if there is an error parsing the projection. - */ -void setProjection(ParsedFindCommand* out, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const std::unique_ptr<FindCommandRequest>& findCommand, - const ProjectionPolicies& policies) { - if (!findCommand->getProjection().isEmpty()) { - out->savedProjectionPolicies.emplace(policies); - out->proj.emplace(projection_ast::parseAndAnalyze(expCtx, - findCommand->getProjection(), - out->filter.get(), - findCommand->getFilter(), - policies)); - - // This will throw if any of the projection's dependencies are unavailable. - DepsTracker{out->unavailableMetadata}.requestMetadata(out->proj->metadataDeps()); - } -} - -/** - * Helper for building 'out.' If there is a sort, parse it and add any metadata dependencies it - * induces. - * - * Throws exceptions if there is an error parsing the sort pattern. - */ -void setSort(ParsedFindCommand* out, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const std::unique_ptr<FindCommandRequest>& findCommand) { - if (!findCommand->getSort().isEmpty()) { - // A $natural sort is really a hint, and should be handled as such. Furthermore, the - // downstream sort handling code may not expect a $natural sort. - // - // We have already validated that if there is a $natural sort and a hint, that the hint - // also specifies $natural with the same direction. Therefore, it is safe to clear the - // $natural sort and rewrite it as a $natural hint. - if (findCommand->getSort()[query_request_helper::kNaturalSortField]) { - findCommand->setHint(findCommand->getSort().getOwned()); - findCommand->setSort(BSONObj{}); - } - if (getTestCommandsEnabled() && internalQueryEnableCSTParser.load()) { - out->sort = cst::parseToSortPattern(findCommand->getSort(), expCtx); - } else { - out->sort.emplace(findCommand->getSort(), expCtx); - } - } -} - -/** - * Helper for building 'out.' If there is a sort, parse it and add any metadata dependencies it - * induces. - */ -Status setSortAndProjection(ParsedFindCommand* out, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const std::unique_ptr<FindCommandRequest>& findCommand, - const ProjectionPolicies& policies) { - try { - setProjection(out, expCtx, findCommand, policies); - setSort(out, expCtx, findCommand); - } catch (const DBException& ex) { - return ex.toStatus(); - } - - return Status::OK(); -} - -/** - * Helper for building 'out.' Sets 'out->filter' and validates that it is well formed. In the - * process, also populates 'out->unavailableMetadata.' - */ -Status setFilter(ParsedFindCommand* out, - std::unique_ptr<MatchExpression> filter, - const std::unique_ptr<FindCommandRequest>& findCommand) { - // Verify the filter follows certain rules like there must be at most one text clause. - auto swMeta = parsed_find_command::isValid(filter.get(), *findCommand); - if (!swMeta.isOK()) { - return swMeta.getStatus(); - } - out->unavailableMetadata = swMeta.getValue(); - out->filter = std::move(filter); - return Status::OK(); -} - - -StatusWith<std::unique_ptr<ParsedFindCommand>> parseWithValidatedCollator( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - std::unique_ptr<FindCommandRequest> findCommand, - const ExtensionsCallback& extensionsCallback, - MatchExpressionParser::AllowedFeatureSet allowedFeatures, - const ProjectionPolicies& projectionPolicies) { - auto out = std::make_unique<ParsedFindCommand>(); - - tassert(5746107, - "ntoreturn should not be set on the findCommand", - findCommand->getNtoreturn() == boost::none); - - if (auto status = query_request_helper::validateFindCommandRequest(*findCommand); - !status.isOK()) { - return status; - } - - // Parse the MatchExpression. - StatusWithMatchExpression statusWithMatcher = [&]() -> StatusWithMatchExpression { - if (getTestCommandsEnabled() && internalQueryEnableCSTParser.load()) { - try { - return cst::parseToMatchExpression( - findCommand->getFilter(), expCtx, extensionsCallback); - } catch (const DBException& ex) { - return ex.toStatus(); - } - } else { - return MatchExpressionParser::parse( - findCommand->getFilter(), expCtx, extensionsCallback, allowedFeatures); - } - }(); - if (!statusWithMatcher.isOK()) { - return statusWithMatcher.getStatus(); - } - - // Stop counting expressions after they have been parsed to exclude expressions created - // during optimization and other processing steps. - expCtx->stopExpressionCounters(); - out->canHaveNoopMatchNodes = - parsingCanProduceNoopMatchNodes(extensionsCallback, allowedFeatures); - - if (auto status = setFilter(out.get(), std::move(statusWithMatcher.getValue()), findCommand); - !status.isOK()) { - return status; - } - - if (auto status = setSortAndProjection(out.get(), expCtx, findCommand, projectionPolicies); - !status.isOK()) { - return status; - } - - out->findCommandRequest = std::move(findCommand); - return {std::move(out)}; -} - -StatusWith<std::unique_ptr<ParsedFindCommand>> ParsedFindCommand::withExistingFilter( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - std::unique_ptr<CollatorInterface> collator, - std::unique_ptr<MatchExpression> filter, - std::unique_ptr<FindCommandRequest> findCommandRequest) { - auto out = std::make_unique<ParsedFindCommand>(); - out->collator = std::move(collator); - if (auto status = setFilter(out.get(), std::move(filter), findCommandRequest); !status.isOK()) { - return status; - } - if (auto status = setSortAndProjection( - out.get(), expCtx, findCommandRequest, ProjectionPolicies::findProjectionPolicies()); - !status.isOK()) { - return status; - } - out->findCommandRequest = std::move(findCommandRequest); - return std::move(out); -} - -namespace parsed_find_command { -StatusWith<QueryMetadataBitSet> isValid(const MatchExpression* root, - const FindCommandRequest& findCommand) { - QueryMetadataBitSet unavailableMetadata{}; - - // There can only be one TEXT. If there is a TEXT, it cannot appear inside a NOR. - // - // Note that the query grammar (as enforced by the MatchExpression parser) forbids TEXT - // inside of value-expression clauses like NOT, so we don't check those here. - size_t numText = QueryPlannerCommon::countNodes(root, MatchExpression::TEXT); - if (numText > 1) { - return Status(ErrorCodes::BadValue, "Too many text expressions"); - } else if (1 == numText) { - if (hasNodeInSubtree(root, MatchExpression::TEXT, MatchExpression::NOR)) { - return Status(ErrorCodes::BadValue, "text expression not allowed in nor"); - } - } else { - // Text metadata is not available. - unavailableMetadata.set(DocumentMetadataFields::kTextScore); - } - - // There can only be one NEAR. If there is a NEAR, it must be either the root or the root - // must be an AND and its child must be a NEAR. - size_t numGeoNear = QueryPlannerCommon::countNodes(root, MatchExpression::GEO_NEAR); - if (numGeoNear > 1) { - return Status(ErrorCodes::BadValue, "Too many geoNear expressions"); - } else if (1 == numGeoNear) { - // Do nothing, we will perform extra checks in CanonicalQuery::isValidNormalized. - } else { - // Geo distance and geo point metadata are unavailable. - unavailableMetadata |= DepsTracker::kAllGeoNearData; - } - - const BSONObj& sortObj = findCommand.getSort(); - BSONElement sortNaturalElt = sortObj["$natural"]; - const BSONObj& hintObj = findCommand.getHint(); - BSONElement hintNaturalElt = hintObj["$natural"]; - - if (sortNaturalElt && sortObj.nFields() != 1) { - return Status(ErrorCodes::BadValue, - str::stream() << "Cannot include '$natural' in compound sort: " << sortObj); - } - - if (hintNaturalElt && hintObj.nFields() != 1) { - return Status(ErrorCodes::BadValue, - str::stream() << "Cannot include '$natural' in compound hint: " << hintObj); - } - - // NEAR cannot have a $natural sort or $natural hint. - if (numGeoNear > 0) { - if (sortNaturalElt) { - return Status(ErrorCodes::BadValue, - "geoNear expression not allowed with $natural sort order"); - } - - if (hintNaturalElt) { - return Status(ErrorCodes::BadValue, - "geoNear expression not allowed with $natural hint"); - } - } - - // TEXT and NEAR cannot both be in the query. - if (numText > 0 && numGeoNear > 0) { - return Status(ErrorCodes::BadValue, "text and geoNear not allowed in same query"); - } - - // TEXT and {$natural: ...} sort order cannot both be in the query. - if (numText > 0 && sortNaturalElt) { - return Status(ErrorCodes::BadValue, "text expression not allowed with $natural sort order"); - } - - // TEXT and hint cannot both be in the query. - if (numText > 0 && !hintObj.isEmpty()) { - return Status(ErrorCodes::BadValue, "text and hint not allowed in same query"); - } - - // TEXT and tailable are incompatible. - if (numText > 0 && findCommand.getTailable()) { - return Status(ErrorCodes::BadValue, "text and tailable cursor not allowed in same query"); - } - - // NEAR and tailable are incompatible. - if (numGeoNear > 0 && findCommand.getTailable()) { - return Status(ErrorCodes::BadValue, - "Tailable cursors and geo $near cannot be used together"); - } - - // $natural sort order must agree with hint. - if (sortNaturalElt) { - if (!hintObj.isEmpty() && !hintNaturalElt) { - return Status(ErrorCodes::BadValue, "index hint not allowed with $natural sort order"); - } - if (hintNaturalElt) { - if (hintNaturalElt.numberInt() != sortNaturalElt.numberInt()) { - return Status(ErrorCodes::BadValue, - "$natural hint must be in the same direction as $natural sort order"); - } - } - } - - return unavailableMetadata; -} - -StatusWith<std::pair<boost::intrusive_ptr<ExpressionContext>, std::unique_ptr<ParsedFindCommand>>> -parse(OperationContext* opCtx, - std::unique_ptr<FindCommandRequest> findCommand, - const ExtensionsCallback& extensionsCallback, - MatchExpressionParser::AllowedFeatureSet allowedFeatures, - const ProjectionPolicies& projectionPolicies) { - // Make the expCtx. - invariant(findCommand->getNamespaceOrUUID().nss().has_value()); - auto expCtx = make_intrusive<ExpressionContext>( - opCtx, *findCommand, resolveCollator(opCtx, findCommand), true /* mayDbProfile */); - auto swResult = parseWithValidatedCollator( - expCtx, std::move(findCommand), extensionsCallback, allowedFeatures, projectionPolicies); - if (!swResult.isOK()) { - return swResult.getStatus(); - } - - return std::pair{std::move(expCtx), std::move(swResult.getValue())}; -} - -StatusWith<std::unique_ptr<ParsedFindCommand>> parse( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - std::unique_ptr<FindCommandRequest> findCommand, - const ExtensionsCallback& extensionsCallback, - MatchExpressionParser::AllowedFeatureSet allowedFeatures, - const ProjectionPolicies& projectionPolicies) { - // A collator can enter through both the FindCommandRequest and ExpressionContext arguments. - // This invariant ensures that both collators are the same because downstream we - // pull the collator from only one of the ExpressionContext carrier. - auto collator = resolveCollator(expCtx->opCtx, findCommand); - if (collator.get() && expCtx->getCollator()) { - invariant(CollatorInterface::collatorsMatch(collator.get(), expCtx->getCollator())); - } - return parseWithValidatedCollator( - expCtx, std::move(findCommand), extensionsCallback, allowedFeatures, projectionPolicies); -} -} // namespace parsed_find_command -} // namespace mongo diff --git a/src/mongo/db/query/parsed_find_command.h b/src/mongo/db/query/parsed_find_command.h deleted file mode 100644 index f3ec78b9204..00000000000 --- a/src/mongo/db/query/parsed_find_command.h +++ /dev/null @@ -1,127 +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. - */ - -#pragma once - -#include "mongo/db/matcher/expression.h" -#include "mongo/db/query/find_command_gen.h" -#include "mongo/db/query/projection.h" -#include "mongo/db/query/projection_policies.h" -#include "mongo/db/query/sort_pattern.h" - -namespace mongo { - -/** - * Represents a find command request, but with more fully parsed ASTs for some fields which are - * still raw BSONObj on the FindCommandRequest type. - */ -struct ParsedFindCommand { - ParsedFindCommand() = default; - - /** - * This API adds the ability to construct from a pre-parsed filter. The other arguments will be - * re-parsed again from BSON on the 'findCommandRequest' argument, since we don't have a good - * way of cloning them. - */ - static StatusWith<std::unique_ptr<ParsedFindCommand>> withExistingFilter( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - std::unique_ptr<CollatorInterface> collator, - std::unique_ptr<MatchExpression> filter, - std::unique_ptr<FindCommandRequest> findCommandRequest); - - std::unique_ptr<CollatorInterface> collator; - std::unique_ptr<MatchExpression> filter; - boost::optional<projection_ast::Projection> proj; - boost::optional<SortPattern> sort; - - // Based on parsing the query, which metadata will *not* be available. For example, if there is - // no $text clause, then a text score will not be available. - QueryMetadataBitSet unavailableMetadata; - - // This is saved for an edge case where we need to re-parse a projection later. Only populated - // if there is a non-empty projection. - boost::optional<ProjectionPolicies> savedProjectionPolicies; - - // True if this canonical query may have converted extensions such as $where and $text into - // no-ops during parsing. This will be the case if it allowed $where and $text in parsing, but - // parsed using an ExtensionsCallbackNoop. This does not guarantee that a $where or $text - // existed in the query. Queries with a no-op extension context are special because they can be - // parsed and planned, but they cannot be executed. - bool canHaveNoopMatchNodes; - - // All other parameters to the find command which do not have AST-like types and can be - // appropriately tracked as raw value types like ints. The fields above like 'filter' are all - // still present in their raw form on this FidnCommandRequest, but it is not expected that they - // will be useful other than to keep the original BSON values around in-memory to avoid copying - // large strings and such. - std::unique_ptr<FindCommandRequest> findCommandRequest; -}; - -namespace parsed_find_command { -/** - * Validates the match expression 'root' as well as the query specified by 'request', checking for - * illegal combinations of operators. Returns a non-OK status if any such illegal combination is - * found. - * - * This method can be called both on normalized and non-normalized 'root'. However, some checks can - * only be performed once the match expressions is normalized. To perform these checks one can call - * 'CanonicalQuery::isValidNormalized()'. - * - * On success, returns a bitset indicating which types of metadata are *unavailable*. For example, - * if 'root' does not contain a $text predicate, then the returned metadata bitset will indicate - * that text score metadata is unavailable. This means that if subsequent $meta:"textScore" - * expressions are found during analysis of the query, we should raise in an error. - */ -StatusWith<QueryMetadataBitSet> isValid(const MatchExpression* root, - const FindCommandRequest& findCommand); - -/** - * Parses each big component of the input 'findCommand.' Throws exceptions if failing to parse. - * Comes in one overload which will create an ExpressionContext for the caller, and one overload to - * be used when the caller already has an ExpressionContext. - */ -StatusWith<std::pair<boost::intrusive_ptr<ExpressionContext>, std::unique_ptr<ParsedFindCommand>>> -parse(OperationContext* opCtx, - std::unique_ptr<FindCommandRequest> findCommand, - const ExtensionsCallback& extensionsCallback = ExtensionsCallbackNoop(), - MatchExpressionParser::AllowedFeatureSet allowedFeatures = - MatchExpressionParser::kDefaultSpecialFeatures, - const ProjectionPolicies& projectionPolicies = ProjectionPolicies::findProjectionPolicies()); - -// Overload of the above for when the caller has an available ExpressionContext. -StatusWith<std::unique_ptr<ParsedFindCommand>> parse( - const boost::intrusive_ptr<ExpressionContext>& expCtx, - std::unique_ptr<FindCommandRequest> findCommand, - const ExtensionsCallback& extensionsCallback = ExtensionsCallbackNoop(), - MatchExpressionParser::AllowedFeatureSet allowedFeatures = - MatchExpressionParser::kDefaultSpecialFeatures, - const ProjectionPolicies& projectionPolicies = ProjectionPolicies::findProjectionPolicies()); - -} // namespace parsed_find_command -} // namespace mongo diff --git a/src/mongo/db/query/partitioned_cache.h b/src/mongo/db/query/partitioned_cache.h deleted file mode 100644 index ca10f731b71..00000000000 --- a/src/mongo/db/query/partitioned_cache.h +++ /dev/null @@ -1,242 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - -#pragma once - -#include "mongo/db/catalog/util/partitioned.h" -#include "mongo/db/commands/server_status_metric.h" -#include "mongo/db/query/lru_key_value.h" -#include "mongo/platform/mutex.h" -#include "mongo/util/container_size_helper.h" - -namespace mongo { - -/** - * A partitioned cache combines a size-bounded map (LRU-based entry eviction) with a partition - * function which allows reducing contention. - */ -template <class KeyType, - class ValueType, - class KeyBudgetEstimator, - class Partitioner, - class InsertionEvictionListener, - class KeyHasher = std::hash<KeyType>, - class Eq = std::equal_to<KeyType>> -class PartitionedCache { -private: - PartitionedCache(const PartitionedCache&) = delete; - PartitionedCache& operator=(const PartitionedCache&) = delete; - -public: - using Lru = LRUKeyValue<KeyType, - ValueType, - KeyBudgetEstimator, - InsertionEvictionListener, - KeyHasher, - Eq>; - using Partition = typename Partitioned<Lru, Partitioner>::OnePartition; - using PartitionId = typename Partitioned<Lru, Partitioner>::PartitionId; - - /** - * Initialize plan cache with the total cache size in bytes and number of partitions. - * - * Important edge cases to consider include: - * - * 1. Adding an entry that is larger than the max partition size to a non-empty partition. - * - * This will evict both entries. This is because entries are evicted from the partition in - * order of least recently used. Thus, the oldest, small entry will be evicted first but the - * partition will still be over budget with the new, too-large entry so it will be evicted as - * well. - * - * 2. Adding a queryStats store entry that is smaller than the overall cache size but larger - * than single partition max size. - * - * It is not possible to write entries to the cache that are larger than a single - * partition's max size, even if it is smaller than the entire cache max size. This is because - * the cache's budget is configured/regulated on the partition level (cacheSize / - * numPartitions). This makes sense as each entry is written to a specific partition, but might - * not be immediately obvious so worthy to highlight. - * - * 3. Too few partitions can cause unnecessary evictions - * - * Every class that implements the PartitionedCache template provides a partitioner() that - * returns the id of the partition to which to write the entry. In existing implementations, - * partitioner() returns the remainder after dividing the entry's key hash by numPartitions. In - * the case where we have only two partitions, every odd key hash will be written to the first - * partition (and vice versa). In this way, it can quickly be the case that one partition - * fills up completely but the partitioner() call keeps returning the already full partition and - * the cache evict old entries from it to put the new one in. At the end of all the write - * operations, the cache is below it's budget (as the second partition is only partially full) - * but we don't have all the entries we expect. It is therefore important to have sufficient - * enough number of partitions so the entries can be more equally dispersed to avoid unnecessary - * evictions. - */ - explicit PartitionedCache(size_t cacheSize, size_t numPartitions) - : _numPartitions(numPartitions) { - invariant(numPartitions > 0); - Lru lru{cacheSize / numPartitions}; - _partitionedCache = - std::make_unique<Partitioned<Lru, Partitioner>>(numPartitions, std::move(lru)); - } - - ~PartitionedCache() = default; - /** - * Inserts the provided <key, value> into the partition associated with that key. Returns the - * number of older entries evicted to fit this new one. - */ - size_t put(const KeyType& key, ValueType value) { - auto partition = _partitionedCache->lockOnePartition(key); - return partition->add(key, std::move(value)); - } - /** - * Inserts the provided <key, value> into the specified partition. Returns the number of older - * entries evicted to fit this new one. - */ - size_t put(const KeyType& key, ValueType value, Partition& partition) { - return partition->add(key, std::move(value)); - } - - StatusWith<ValueType*> lookup(const KeyType& key) const { - auto partition = _partitionedCache->lockOnePartition(key); - auto entry = partition->get(key); - if (!entry.isOK()) { - return {entry.getStatus()}; - } - - return {&entry.getValue()->second}; - } - - /** - * Lookup an entry and also return a lock over the partition. The lock is returned whether - * or not the entry is found. - */ - std::pair<StatusWith<ValueType*>, Partition> getWithPartitionLock(const KeyType& key) const { - auto partition = _partitionedCache->lockOnePartition(key); - auto entry = partition->get(key); - if (!entry.isOK()) { - return std::make_pair(entry.getStatus(), std::move(partition)); - } - - return std::make_pair(StatusWith{&entry.getValue()->second}, std::move(partition)); - } - - /** - * Remove the entry with the 'key' from the cache. If there is no entry for the given key in - * the cache, this call is a no-op. - */ - void remove(const KeyType& key) { - _partitionedCache->erase(key); - } - - /** - * Remove all the entries for keys for which the predicate returns true. Return the number of - * removed entries. - */ - template <typename UnaryPredicate> - size_t removeIf(UnaryPredicate predicate) { - size_t nRemoved = 0; - for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { - auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); - nRemoved += lockedPartition->removeIf(predicate); - } - return nRemoved; - } - - /** - * Remove *all* cache entries. - */ - void clear() { - _partitionedCache->clear(); - } - - /** - * Reset total cache size. If the size is set to a smaller value than before, enough entries are - * evicted in order to ensure that the cache fits within the new budget. Returns the number of - * entries evicted. - */ - size_t reset(size_t cacheSize) { - size_t numEvicted = 0; - for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { - auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); - numEvicted += lockedPartition->reset(cacheSize / _numPartitions); - } - - return numEvicted; - } - - /** - * Returns the size of the cache. - * Used for testing. - */ - size_t size() const { - return _partitionedCache->size(); - } - - /** - * Returns the number of partitions. - */ - size_t numPartitions() const { - return _numPartitions; - } - - /** - * Invoke `op` for each entry in the cache. Consistency across partitions is not guaranteed. - */ - void forEach(const std::function<void(const KeyType&, const ValueType&)>& op) const { - for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { - auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); - - for (auto&& [key, entry] : *lockedPartition) { - op(*key, entry); - } - } - } - - /** - * Allow iterating over partitions. The provided function is called for each partition. The - * argument to the function is another function which can delay acquiring the implicitly locked - * partition until it's needed. - */ - void forEachPartition(const std::function<void(const std::function<Partition()>&)>& op) const { - for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { - op([&]() { return _partitionedCache->lockOnePartitionById(partitionId); }); - } - } - - Partition getPartition(PartitionId partitionId) { - return _partitionedCache->lockOnePartitionById(partitionId); - } - -private: - std::size_t _numPartitions; - std::unique_ptr<Partitioned<Lru, Partitioner>> _partitionedCache; -}; - -} // namespace mongo diff --git a/src/mongo/db/query/plan_cache.h b/src/mongo/db/query/plan_cache.h index e193309230e..dc52b10c4f4 100644 --- a/src/mongo/db/query/plan_cache.h +++ b/src/mongo/db/query/plan_cache.h @@ -31,7 +31,6 @@ #include "mongo/db/catalog/util/partitioned.h" #include "mongo/db/query/lru_key_value.h" -#include "mongo/db/query/partitioned_cache.h" #include "mongo/db/query/plan_cache_callbacks.h" #include "mongo/db/query/plan_cache_debug_info.h" #include "mongo/platform/mutex.h" @@ -282,34 +281,21 @@ private: */ template <class KeyType, class CachedPlanType, - class KeyBudgetEstimator, + class BudgetEstimator, class DebugInfoType, class Partitioner, class KeyHasher = std::hash<KeyType>> -class PlanCacheBase - : public PartitionedCache< - KeyType, - // The 'Value' being "std::shared_ptr<const Entry>" is because we allow readers to clone - // cache entries out of the lock, therefore it is illegal to mutate the pieces of a cache - // entry that can be cloned whether you are holding a lock or not. - std::shared_ptr<const PlanCacheEntryBase<CachedPlanType, DebugInfoType>>, - KeyBudgetEstimator, - Partitioner, - NoopInsertionEvictionListener, - KeyHasher> { +class PlanCacheBase { private: PlanCacheBase(const PlanCacheBase&) = delete; PlanCacheBase& operator=(const PlanCacheBase&) = delete; public: - using Base = - PartitionedCache<KeyType, - std::shared_ptr<const PlanCacheEntryBase<CachedPlanType, DebugInfoType>>, - KeyBudgetEstimator, - Partitioner, - NoopInsertionEvictionListener, - KeyHasher>; using Entry = PlanCacheEntryBase<CachedPlanType, DebugInfoType>; + // The 'Value' being "std::shared_ptr<const Entry>" is because we allow readers to clone cache + // entries out of the lock, therefore it is illegal to mutate the pieces of a cache entry that + // can be cloned whether you are holding a lock or not. + using Lru = LRUKeyValue<KeyType, std::shared_ptr<const Entry>, BudgetEstimator, KeyHasher>; // We have three states for a cache entry to be in. Rather than just 'present' or 'not // present', we use a notion of 'inactive entries' as a way of remembering how performant our @@ -342,7 +328,11 @@ public: * Initialize plan cache with the total cache size in bytes and number of partitions. */ explicit PlanCacheBase(size_t cacheSize, size_t numPartitions = 1) - : Base(cacheSize, numPartitions) {} + : _numPartitions(numPartitions) { + invariant(numPartitions > 0); + Lru lru{cacheSize / numPartitions}; + _partitionedCache = std::make_unique<Partitioned<Lru, Partitioner>>(numPartitions, lru); + } ~PlanCacheBase() = default; @@ -385,11 +375,7 @@ public: }}, why.stats); - auto oldEntryWithPartitionLock = this->getWithPartitionLock(key); - // Can't use reference to structured bindings in a lambda until C++20 so manually - // destructure it here. - auto partitionLock = std::move(oldEntryWithPartitionLock.second); - auto oldEntryWithStatus = std::move(oldEntryWithPartitionLock.first); + auto partition = _partitionedCache->lockOnePartition(key); auto [queryHash, planCacheKey, isNewEntryActive, shouldBeCreated, increasedWorks] = [&]() { if (internalQueryCacheDisableInactiveEntries.load()) { // All entries are always active. @@ -399,34 +385,32 @@ public: true /* shouldBeCreated */, boost::optional<size_t>(boost::none)); } else { + auto oldEntryWithStatus = partition->get(key); tassert(6007020, "LRU store must get value or NoSuchKey error code", oldEntryWithStatus.isOK() || oldEntryWithStatus.getStatus() == ErrorCodes::NoSuchKey); - bool hasOldEntry = oldEntryWithStatus.isOK(); + auto oldEntry = + oldEntryWithStatus.isOK() ? oldEntryWithStatus.getValue()->second : nullptr; const auto newState = getNewEntryState( key, - // Deference the pointer, then the shared_ptr, and then back to a raw pointer. - hasOldEntry ? &**oldEntryWithStatus.getValue() : nullptr, + oldEntry.get(), newWorks, worksGrowthCoefficient.get_value_or(internalQueryCacheWorksGrowthCoefficient), callbacks); // Avoid recomputing the hashes if we've got an old entry to grab them from. - auto [queryHash, planCacheKey] = [&]() { - if (hasOldEntry) { - auto&& oldEntry = &**oldEntryWithStatus.getValue(); - return std::make_pair(oldEntry->queryHash, oldEntry->planCacheKey); - } else { - return std::make_pair(key.queryHash(), key.planCacheKeyHash()); - } - }(); - return std::make_tuple(queryHash, - planCacheKey, - newState.shouldBeActive, - newState.shouldBeCreated, - newState.increasedWorks); + return oldEntry ? std::make_tuple(oldEntry->queryHash, + oldEntry->planCacheKey, + newState.shouldBeActive, + newState.shouldBeCreated, + newState.increasedWorks) + : std::make_tuple(key.queryHash(), + key.planCacheKeyHash(), + newState.shouldBeActive, + newState.shouldBeCreated, + newState.increasedWorks); } }(); @@ -450,7 +434,7 @@ public: increasedWorks ? *increasedWorks : newWorks, callbacks->buildDebugInfo()); - this->put(key, std::move(newEntry), partitionLock); + partition->add(key, std::move(newEntry)); return Status::OK(); } @@ -470,7 +454,10 @@ public: indexFilterKey, now, std::move(debugInfo)); - this->put(key, std::move(entry)); + auto partition = _partitionedCache->lockOnePartition(key); + // We're not interested in the number of evicted entries if the cache store exceeds the + // budget after add(), so we just ignore the return value. + partition->add(key, std::move(entry)); } /** @@ -484,8 +471,8 @@ public: return; } - auto [entry, partitionLock] = this->getWithPartitionLock(key); - + auto partition = _partitionedCache->lockOnePartition(key); + auto entry = partition->get(key); if (!entry.isOK()) { tassert(6007021, "Unexpected error code from LRU store", @@ -493,11 +480,11 @@ public: return; } - auto entryPtr = *entry.getValue(); + auto entryPtr = entry.getValue()->second; if (entryPtr->isActive == true) { std::shared_ptr<Entry> newEntry = entryPtr->clone(); newEntry->isActive = false; - this->put(key, std::move(newEntry), partitionLock); + partition->add(key, std::move(newEntry)); } } @@ -509,26 +496,29 @@ public: * for the query (if there is one). */ GetResult get(const KeyType& key) const { - std::shared_ptr<const Entry> entrySharedPtr; + std::shared_ptr<const Entry> entryPtr; CacheEntryState state; { - auto [entry, partitionLock] = this->getWithPartitionLock(key); + auto partition = _partitionedCache->lockOnePartition(key); + auto entry = partition->get(key); if (!entry.isOK()) { tassert(6007023, "Unexpected error code from LRU store", entry.getStatus() == ErrorCodes::NoSuchKey); return {CacheEntryState::kNotPresent, nullptr}; } - entrySharedPtr = *entry.getValue(); - state = entrySharedPtr->isActive ? CacheEntryState::kPresentActive - : CacheEntryState::kPresentInactive; + entryPtr = entry.getValue()->second; + state = entryPtr->isActive ? CacheEntryState::kPresentActive + : CacheEntryState::kPresentInactive; } - // The purpose of cloning 'entry' (in CachedPlanHolder ctor) after we release the lock - // is to allow multiple threads to clone the same plan cache entry at once. 'entry' - // cannot be deleted by another thread even if the plan cache is being concurrently - // modified by other threads because we are holding a std::shared_ptr to this entry. + // The purpose of cloning 'entry' after we release the lock is to allow multiple threads to + // clone the same plan cache entry at once. 'entry' cannot be deleted by another thread even + // if the plan cache is being concurrently modified by other threads because we are holding + // a std::shared_ptr to this entry. + tassert(6007024, "LRU store must get a value or an error code", entryPtr); + return {state, - std::make_unique<CachedPlanHolder<CachedPlanType, DebugInfoType>>(*entrySharedPtr)}; + std::make_unique<CachedPlanHolder<CachedPlanType, DebugInfoType>>(*entryPtr)}; } /** @@ -547,16 +537,59 @@ public: } /** + * Remove the entry with the 'key' from the cache. If there is no entry for the given key in + * the cache, this call is a no-op. + */ + void remove(const KeyType& key) { + _partitionedCache->erase(key); + } + + /** + * Remove all the entries for keys for which the predicate returns true. Return the number of + * removed entries. + */ + template <typename UnaryPredicate> + size_t removeIf(UnaryPredicate predicate) { + size_t nRemoved = 0; + for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { + auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); + nRemoved += lockedPartition->removeIf(predicate); + } + return nRemoved; + } + + /** + * Remove *all* cached plans. Does not clear index information. + */ + void clear() { + _partitionedCache->clear(); + } + + /** + * Reset total cache size. If the size is set to a smaller value than before, enough entries are + * evicted in order to ensure that the cache fits within the new budget. + */ + void reset(size_t cacheSize) { + for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { + auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); + lockedPartition->reset(cacheSize / _numPartitions); + } + } + + /** * Returns a copy of a cache entry, looked up by the plan cache key. * * If there is no entry in the cache for the 'query', returns an error Status. */ StatusWith<std::unique_ptr<Entry>> getEntry(const KeyType& key) const { - auto result = this->lookup(key); - if (!result.isOK()) { - return {result.getStatus()}; + auto partition = _partitionedCache->lockOnePartition(key); + auto entry = partition->get(key); + if (!entry.isOK()) { + return entry.getStatus(); } - return {result.getValue()->get()->clone()}; + invariant(entry.getValue()->second); + + return std::unique_ptr<Entry>(entry.getValue()->second->clone()); } /** @@ -565,14 +598,26 @@ public: std::vector<std::unique_ptr<Entry>> getAllEntries() const { std::vector<std::unique_ptr<Entry>> entries; - this->forEach([&](const KeyType& key, const std::shared_ptr<Entry>& entry) { - entries.emplace_back(entry); - }); + for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { + auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); + + for (auto&& [key, entry] : *lockedPartition) { + entries.emplace_back(entry->clone()); + } + } return entries; } /** + * Returns the size of the cache. + * Used for testing. + */ + size_t size() const { + return _partitionedCache->size(); + } + + /** * Iterates over the plan cache. For each entry, first filters according to the predicate * function 'cacheKeyFilterFunc', (Note that 'cacheKeyFilterFunc' could be empty, if so, we * don't filter by plan cache key.), then serializes the PlanCacheEntryBase according to @@ -589,15 +634,20 @@ public: std::vector<BSONObj> results; - this->forEach([&](const KeyType& key, const std::shared_ptr<const Entry>& entry) { - if (cacheKeyFilterFunc && !cacheKeyFilterFunc(key)) { - return; - } - auto serializedEntry = serializationFunc(*entry); - if (filterFunc(serializedEntry)) { - results.push_back(serializedEntry); + for (size_t partitionId = 0; partitionId < _numPartitions; ++partitionId) { + auto lockedPartition = _partitionedCache->lockOnePartitionById(partitionId); + + for (auto&& cacheEntry : *lockedPartition) { + if (cacheKeyFilterFunc && !cacheKeyFilterFunc(cacheEntry.first)) { + continue; + } + const auto& entry = cacheEntry.second; + auto serializedEntry = serializationFunc(*entry); + if (filterFunc(serializedEntry)) { + results.push_back(serializedEntry); + } } - }); + } return results; } @@ -685,6 +735,9 @@ private: return res; } + + std::size_t _numPartitions; + std::unique_ptr<Partitioned<Lru, Partitioner>> _partitionedCache; }; } // namespace mongo diff --git a/src/mongo/db/query/plan_cache_indexability.cpp b/src/mongo/db/query/plan_cache_indexability.cpp index 0498d5edc26..4f1b0c176f8 100644 --- a/src/mongo/db/query/plan_cache_indexability.cpp +++ b/src/mongo/db/query/plan_cache_indexability.cpp @@ -79,6 +79,7 @@ IndexabilityDiscriminator getCollatedIndexDiscriminator(const CollatorInterface* } return true; } + // The predicate never compares strings so it is not affected by collation. return true; }; @@ -103,7 +104,14 @@ void PlanCacheIndexabilityState::processSparseIndex(const std::string& indexName void PlanCacheIndexabilityState::processPartialIndex(const std::string& indexName, const MatchExpression* filterExpr) { - _globalDiscriminatorMap[indexName].addDiscriminator(getPartialIndexDiscriminator(filterExpr)); + invariant(filterExpr); + for (size_t i = 0; i < filterExpr->numChildren(); ++i) { + processPartialIndex(indexName, filterExpr->getChild(i)); + } + if (filterExpr->getCategory() != MatchExpression::MatchCategory::kLogical) { + _pathDiscriminatorsMap[filterExpr->path()][indexName].addDiscriminator( + getPartialIndexDiscriminator(filterExpr)); + } } void PlanCacheIndexabilityState::processWildcardIndex(const CoreIndexInfo& cii) { @@ -126,7 +134,7 @@ namespace { const IndexToDiscriminatorMap emptyDiscriminators{}; } // namespace -const IndexToDiscriminatorMap& PlanCacheIndexabilityState::getPathDiscriminators( +const IndexToDiscriminatorMap& PlanCacheIndexabilityState::getDiscriminators( StringData path) const { PathDiscriminatorsMap::const_iterator it = _pathDiscriminatorsMap.find(path); if (it == _pathDiscriminatorsMap.end()) { @@ -158,7 +166,6 @@ IndexToDiscriminatorMap PlanCacheIndexabilityState::buildWildcardDiscriminators( void PlanCacheIndexabilityState::updateDiscriminators( const std::vector<CoreIndexInfo>& indexCores) { _pathDiscriminatorsMap = PathDiscriminatorsMap(); - _globalDiscriminatorMap = IndexToDiscriminatorMap(); _wildcardIndexDiscriminators.clear(); for (const auto& idx : indexCores) { diff --git a/src/mongo/db/query/plan_cache_indexability.h b/src/mongo/db/query/plan_cache_indexability.h index 0aa08359c27..9bc03494865 100644 --- a/src/mongo/db/query/plan_cache_indexability.h +++ b/src/mongo/db/query/plan_cache_indexability.h @@ -47,7 +47,6 @@ class ProjectionExecutor; using IndexabilityDiscriminator = std::function<bool(const MatchExpression* me)>; using IndexabilityDiscriminators = std::vector<IndexabilityDiscriminator>; using IndexToDiscriminatorMap = StringMap<CompositeIndexabilityDiscriminator>; -using PathDiscriminatorsMap = StringMap<IndexToDiscriminatorMap>; /** * CompositeIndexabilityDiscriminator holds all indexability discriminators for a particular path, @@ -78,14 +77,9 @@ private: }; /** - * PlanCacheIndexabilityState holds a set of "indexability discriminators. An indexability - * discriminator is a binary predicate function, used to classify match expressions based on the - * data values in the expression. - * - * These discriminators are used to distinguish between queries of a similar shape but not the same - * candidate indexes. So each discriminator typically represents a decision like "is this index - * valid?" or "does this piece of the query disqualify it from using this index?". The output of - * these decisions is included in the plan cache key. + * PlanCacheIndexabilityState holds a set of "indexability discriminators" for certain paths. + * An indexability discriminator is a binary predicate function, used to classify match + * expressions based on the data values in the expression. */ class PlanCacheIndexabilityState { PlanCacheIndexabilityState(const PlanCacheIndexabilityState&) = delete; @@ -101,15 +95,7 @@ public: * The object returned by reference is valid until the next call to updateDiscriminators() or * until destruction of 'this', whichever is first. */ - const IndexToDiscriminatorMap& getPathDiscriminators(StringData path) const; - - /** - * Returns a map of index name to discriminator set. These discriminators are not - * associated with a particular path of a query and apply to the entire MatchExpression. - */ - const IndexToDiscriminatorMap& getGlobalDiscriminators() const { - return _globalDiscriminatorMap; - } + const IndexToDiscriminatorMap& getDiscriminators(StringData path) const; /** * Construct an IndexToDiscriminator map for the given path, only for the wildcard indexes @@ -123,6 +109,8 @@ public: void updateDiscriminators(const std::vector<CoreIndexInfo>& indexCores); private: + using PathDiscriminatorsMap = StringMap<IndexToDiscriminatorMap>; + /** * A $** index may index an infinite number of fields. We cannot just store a discriminator for * every possible field that it indexes, so we have to maintain some special context about the @@ -154,8 +142,8 @@ private: void processSparseIndex(const std::string& indexName, const BSONObj& keyPattern); /** - * Adds a global discriminator for the partial index with the given filter expression - * to the discriminators for that index in '_globalDiscriminatorMap'. + * Adds partial index discriminators for the partial index with the given filter expression + * to the discriminators for that index in '_pathDiscriminatorsMap'. * * A partial index discriminator distinguishes expressions that match a given partial index * predicate from expressions that don't match the partial index predicate. For example, @@ -186,10 +174,6 @@ private: // PathDiscriminatorsMap is a map from field path to index name to IndexabilityDiscriminator. PathDiscriminatorsMap _pathDiscriminatorsMap; - // Map from index name to global discriminators. These are discriminators which do not apply to - // a single path but the entire MatchExpression. - IndexToDiscriminatorMap _globalDiscriminatorMap; - std::vector<WildcardIndexDiscriminatorContext> _wildcardIndexDiscriminators; }; diff --git a/src/mongo/db/query/plan_cache_indexability_test.cpp b/src/mongo/db/query/plan_cache_indexability_test.cpp index 49f9fb79285..af7677a8cd5 100644 --- a/src/mongo/db/query/plan_cache_indexability_test.cpp +++ b/src/mongo/db/query/plan_cache_indexability_test.cpp @@ -104,7 +104,7 @@ TEST(PlanCacheIndexabilityTest, SparseIndexSimple) { nullptr, nullptr)}); - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); @@ -146,7 +146,7 @@ TEST(PlanCacheIndexabilityTest, SparseIndexCompound) { nullptr)}); { - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1_b_1") != discriminators.end()); @@ -159,7 +159,7 @@ TEST(PlanCacheIndexabilityTest, SparseIndexCompound) { } { - auto discriminators = state.getPathDiscriminators("b"); + auto discriminators = state.getDiscriminators("b"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1_b_1") != discriminators.end()); @@ -193,17 +193,12 @@ TEST(PlanCacheIndexabilityTest, PartialIndexSimple) { nullptr, nullptr)}); - // The partial index is represented as a global discriminator that applies to the entire - // incoming MatchExpression. { - auto discriminators = state.getPathDiscriminators("f"); - ASSERT_EQ(0U, discriminators.size()); - - auto globalDiscriminators = state.getGlobalDiscriminators(); - ASSERT_EQ(1U, globalDiscriminators.size()); - ASSERT(globalDiscriminators.find("a_1") != globalDiscriminators.end()); + auto discriminators = state.getDiscriminators("f"); + ASSERT_EQ(1U, discriminators.size()); + ASSERT(discriminators.find("a_1") != discriminators.end()); - auto disc = globalDiscriminators["a_1"]; + auto disc = discriminators["a_1"]; ASSERT_EQ(false, disc.isMatchCompatibleWithIndex( parseMatchExpression(BSON("f" << BSON("$gt" << -5))).get())); @@ -213,7 +208,7 @@ TEST(PlanCacheIndexabilityTest, PartialIndexSimple) { } { - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); @@ -248,52 +243,32 @@ TEST(PlanCacheIndexabilityTest, PartialIndexAnd) { nullptr, nullptr)}); - // partial index discriminators are global to the entire query, so an individual path should not - // have any discriminators. Also the entire query must be a subset of the partial filter - // expression, not just the leaves. - auto globalDiscriminators = state.getGlobalDiscriminators(); - ASSERT(globalDiscriminators.find("a_1") != globalDiscriminators.end()); - auto globalDisc = globalDiscriminators["a_1"]; - { - auto discriminators = state.getPathDiscriminators("f"); - ASSERT_EQ(0U, discriminators.size()); + auto discriminators = state.getDiscriminators("f"); + ASSERT_EQ(1U, discriminators.size()); + ASSERT(discriminators.find("a_1") != discriminators.end()); - ASSERT_EQ( - false, - globalDisc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); - ASSERT_EQ( - false, - globalDisc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); + auto disc = discriminators["a_1"]; + ASSERT_EQ(false, + disc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); + ASSERT_EQ(true, + disc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); } { - auto discriminators = state.getPathDiscriminators("g"); - ASSERT_EQ(0U, discriminators.size()); - - ASSERT_EQ( - false, - globalDisc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("g" << 0)).get())); - ASSERT_EQ( - false, - globalDisc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("g" << 1)).get())); - } + auto discriminators = state.getDiscriminators("g"); + ASSERT_EQ(1U, discriminators.size()); + ASSERT(discriminators.find("a_1") != discriminators.end()); - { - // A match expression which is covered entirely by the partial filter should pass the global - // discriminator. + auto disc = discriminators["a_1"]; ASSERT_EQ(false, - globalDisc.isMatchCompatibleWithIndex( - parseMatchExpression(BSON("g" << 1 << "f" << 0)).get())); + disc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("g" << 0)).get())); ASSERT_EQ(true, - globalDisc.isMatchCompatibleWithIndex( - parseMatchExpression(BSON("g" << 1 << "f" << 1)).get())); + disc.isMatchCompatibleWithIndex(parseMatchExpression(BSON("g" << 1)).get())); } { - // The path 'a' will still have a discriminator for the collation (even though it's - // defaulted). - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); @@ -344,44 +319,33 @@ TEST(PlanCacheIndexabilityTest, MultiplePartialIndexes) { nullptr, nullptr)}); - // partial index discriminators are global to the entire query, so an individual path within the - // partial filter should not have any discriminators. Also the entire query must be a subset of - // the partial filter expression, not just the leaves. - auto globalDiscriminators = state.getGlobalDiscriminators(); - ASSERT(globalDiscriminators.find("a_1") != globalDiscriminators.end()); - ASSERT(globalDiscriminators.find("b_1") != globalDiscriminators.end()); - auto globalDiscA = globalDiscriminators["a_1"]; - auto globalDiscB = globalDiscriminators["b_1"]; - { - auto discriminators = state.getPathDiscriminators("f"); - ASSERT_EQ(0U, discriminators.size()); + auto discriminators = state.getDiscriminators("f"); + ASSERT_EQ(2U, discriminators.size()); + ASSERT(discriminators.find("a_1") != discriminators.end()); + ASSERT(discriminators.find("b_1") != discriminators.end()); - ASSERT_EQ( - false, - globalDiscA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); - ASSERT_EQ( - false, - globalDiscB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); + auto discA = discriminators["a_1"]; + auto discB = discriminators["b_1"]; - ASSERT_EQ( - true, - globalDiscA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); - ASSERT_EQ( - false, - globalDiscB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); + ASSERT_EQ(false, + discA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); + ASSERT_EQ(false, + discB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 0)).get())); - ASSERT_EQ( - false, - globalDiscA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 2)).get())); - ASSERT_EQ( - true, - globalDiscB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 2)).get())); + ASSERT_EQ(true, + discA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); + ASSERT_EQ(false, + discB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 1)).get())); + + ASSERT_EQ(false, + discA.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 2)).get())); + ASSERT_EQ(true, + discB.isMatchCompatibleWithIndex(parseMatchExpression(BSON("f" << 2)).get())); } - // The paths 'a' and 'b' will have one discriminator each to capture the collation of the index. { - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); @@ -395,7 +359,7 @@ TEST(PlanCacheIndexabilityTest, MultiplePartialIndexes) { } { - auto discriminators = state.getPathDiscriminators("b"); + auto discriminators = state.getDiscriminators("b"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("b_1") != discriminators.end()); @@ -428,7 +392,7 @@ TEST(PlanCacheIndexabilityTest, IndexNeitherSparseNorPartial) { BSONObj(), nullptr, nullptr)}); - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); } @@ -457,7 +421,7 @@ TEST(PlanCacheIndexabilityTest, DiscriminatorForCollationIndicatesWhenCollations boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest()); expCtx->setCollator(collator.clone()); - auto discriminators = state.getPathDiscriminators("a"); + auto discriminators = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminators.size()); ASSERT(discriminators.find("a_1") != discriminators.end()); @@ -542,11 +506,11 @@ TEST(PlanCacheIndexabilityTest, CompoundIndexCollationDiscriminator) { nullptr, nullptr)}); - auto discriminatorsA = state.getPathDiscriminators("a"); + auto discriminatorsA = state.getDiscriminators("a"); ASSERT_EQ(1U, discriminatorsA.size()); ASSERT(discriminatorsA.find("a_1_b_1") != discriminatorsA.end()); - auto discriminatorsB = state.getPathDiscriminators("b"); + auto discriminatorsB = state.getDiscriminators("b"); ASSERT_EQ(1U, discriminatorsB.size()); ASSERT(discriminatorsB.find("a_1_b_1") != discriminatorsB.end()); } @@ -655,15 +619,13 @@ TEST(PlanCacheIndexabilityTest, WildcardPartialIndexDiscriminator) { ASSERT_TRUE(wildcardDiscriminators.isMatchCompatibleWithIndex( parseMatchExpression(fromjson("{b: 6}")).get())); - // The global discriminator for the index "indexName" should reflect whether a MatchExpression - // is compatible with the partial filter expression. + // The regular (non-wildcard) set of discriminators for the path "a" should reflect whether a + // predicate on "a" is compatible with the partial filter expression. { - discriminatorsA = state.getPathDiscriminators("a"); - ASSERT(discriminatorsA.find("indexName") == discriminatorsA.end()); - - auto globalDisc = state.getGlobalDiscriminators(); - ASSERT(globalDisc.find("indexName") != globalDisc.end()); - auto disc = globalDisc["indexName"]; + discriminatorsA = state.getDiscriminators("a"); + auto discriminatorsIt = discriminatorsA.find("indexName"); + ASSERT(discriminatorsIt != discriminatorsA.end()); + auto disc = discriminatorsIt->second; ASSERT_FALSE( disc.isMatchCompatibleWithIndex(parseMatchExpression(fromjson("{a: 0}")).get())); @@ -678,7 +640,7 @@ TEST(PlanCacheIndexabilityTest, WildcardPartialIndexDiscriminator) { // There shouldn't be any regular discriminators associated with path "b". { - auto&& discriminatorsB = state.getPathDiscriminators("b"); + auto&& discriminatorsB = state.getDiscriminators("b"); ASSERT_FALSE(discriminatorsB.count("indexName")); } } diff --git a/src/mongo/db/query/plan_cache_key_factory.cpp b/src/mongo/db/query/plan_cache_key_factory.cpp index c5dbfbd7ea4..d47f1768858 100644 --- a/src/mongo/db/query/plan_cache_key_factory.cpp +++ b/src/mongo/db/query/plan_cache_key_factory.cpp @@ -29,29 +29,30 @@ #include "mongo/db/query/plan_cache_key_factory.h" -#include "mongo/db/query/canonical_query_encoder.h" #include "mongo/db/query/collection_query_info.h" #include "mongo/db/query/planner_ixselect.h" #include "mongo/db/s/operation_sharding_state.h" namespace mongo { namespace plan_cache_detail { +// Delimiters for cache key encoding. +const char kEncodeDiscriminatorsBegin = '<'; +const char kEncodeDiscriminatorsEnd = '>'; void encodeIndexabilityForDiscriminators(const MatchExpression* tree, const IndexToDiscriminatorMap& discriminators, StringBuilder* keyBuilder) { - for (auto&& indexAndDiscriminatorPair : discriminators) { *keyBuilder << indexAndDiscriminatorPair.second.isMatchCompatibleWithIndex(tree); } } -void encodeIndexabilityRecursive(const MatchExpression* tree, - const PlanCacheIndexabilityState& indexabilityState, - StringBuilder* keyBuilder) { +void encodeIndexability(const MatchExpression* tree, + const PlanCacheIndexabilityState& indexabilityState, + StringBuilder* keyBuilder) { if (!tree->path().empty()) { const IndexToDiscriminatorMap& discriminators = - indexabilityState.getPathDiscriminators(tree->path()); + indexabilityState.getDiscriminators(tree->path()); IndexToDiscriminatorMap wildcardDiscriminators = indexabilityState.buildWildcardDiscriminators(tree->path()); if (!discriminators.empty() || !wildcardDiscriminators.empty()) { @@ -71,26 +72,8 @@ void encodeIndexabilityRecursive(const MatchExpression* tree, } for (size_t i = 0; i < tree->numChildren(); ++i) { - encodeIndexabilityRecursive(tree->getChild(i), indexabilityState, keyBuilder); - } -} - -void encodeIndexability(const MatchExpression* tree, - const PlanCacheIndexabilityState& indexabilityState, - StringBuilder* keyBuilder) { - // Before encoding the indexability of the leaf MatchExpressions, apply the global - // discriminators to the expression as a whole. This is for cases such as partial indexes which - // must discriminate based on the entire query. - const auto& globalDiscriminators = indexabilityState.getGlobalDiscriminators(); - if (!globalDiscriminators.empty()) { - *keyBuilder << kEncodeGlobalDiscriminatorsBegin; - for (auto&& indexAndDiscriminatorPair : globalDiscriminators) { - *keyBuilder << indexAndDiscriminatorPair.second.isMatchCompatibleWithIndex(tree); - } - *keyBuilder << kEncodeGlobalDiscriminatorsEnd; + encodeIndexability(tree->getChild(i), indexabilityState, keyBuilder); } - - encodeIndexabilityRecursive(tree, indexabilityState, keyBuilder); } PlanCacheKeyInfo makePlanCacheKeyInfo(const CanonicalQuery& query, @@ -128,8 +111,8 @@ boost::optional<Timestamp> computeNewestVisibleIndexTimestamp(OperationContext* Timestamp currentNewestVisible = Timestamp::min(); - auto ii = collection->getIndexCatalog()->getIndexIterator( - opCtx, IndexCatalog::InclusionPolicy::kReady | IndexCatalog::InclusionPolicy::kUnfinished); + std::unique_ptr<IndexCatalog::IndexIterator> ii = + collection->getIndexCatalog()->getIndexIterator(opCtx, /*includeUnfinishedIndexes*/ true); while (ii->more()) { const IndexCatalogEntry* ice = ii->next(); auto minVisibleSnapshot = ice->getMinimumVisibleSnapshot(); diff --git a/src/mongo/db/query/plan_cache_key_info_test.cpp b/src/mongo/db/query/plan_cache_key_info_test.cpp index a13616e12c4..7235386e7f4 100644 --- a/src/mongo/db/query/plan_cache_key_info_test.cpp +++ b/src/mongo/db/query/plan_cache_key_info_test.cpp @@ -194,107 +194,6 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyPartialIndex) { makeKey(*cqGtZero, indexCores)); } -TEST(PlanCacheKeyInfoTest, ComputeKeyPartialIndexConjunction) { - BSONObj filterObj = fromjson("{f: {$gt: 0, $lt: 10}}"); - unique_ptr<MatchExpression> filterExpr(parseMatchExpression(filterObj)); - - const auto keyPattern = BSON("a" << 1); - const std::vector<CoreIndexInfo> indexCores = { - CoreIndexInfo(keyPattern, - IndexNames::nameToType(IndexNames::findPluginName(keyPattern)), - false, // sparse - IndexEntry::Identifier{""}, // name - filterExpr.get())}; // filterExpr - - unique_ptr<CanonicalQuery> satisfySinglePredicate(canonicalize("{f: {$gt: 0}}")); - ASSERT_EQ(makeKey(*satisfySinglePredicate, indexCores).getIndexabilityDiscriminators(), "(0)"); - - unique_ptr<CanonicalQuery> satisfyBothPredicates(canonicalize("{f: {$eq: 5}}")); - ASSERT_EQ(makeKey(*satisfyBothPredicates, indexCores).getIndexabilityDiscriminators(), "(1)"); - - unique_ptr<CanonicalQuery> conjSingleField(canonicalize("{f: {$gt: 2, $lt: 9}}")); - ASSERT_EQ(makeKey(*conjSingleField, indexCores).getIndexabilityDiscriminators(), "(1)"); - - unique_ptr<CanonicalQuery> conjSingleFieldNoMatch(canonicalize("{f: {$gt: 2, $lt: 11}}")); - ASSERT_EQ(makeKey(*conjSingleFieldNoMatch, indexCores).getIndexabilityDiscriminators(), "(0)"); - - // Note that these queries get optimized to a single $in over 'f'. - unique_ptr<CanonicalQuery> disjSingleFieldBothSatisfy( - canonicalize("{$or: [{f: {$eq: 2}}, {f: {$eq: 3}}]}")); - ASSERT_EQ(makeKey(*disjSingleFieldBothSatisfy, indexCores).getIndexabilityDiscriminators(), - "(1)"); - - unique_ptr<CanonicalQuery> disjSingleFieldNotSubset( - canonicalize("{$or: [{f: {$eq: 2}}, {f: {$eq: 11}}]}")); - ASSERT_EQ(makeKey(*disjSingleFieldNotSubset, indexCores).getIndexabilityDiscriminators(), - "(0)"); -} - -TEST(PlanCacheKeyInfoTest, ComputeKeyPartialIndexDisjunction) { - BSONObj filterObj = fromjson("{$or: [{f: {$gt: 10}}, {f: {$lt: 0}}]}"); - unique_ptr<MatchExpression> filterExpr(parseMatchExpression(filterObj)); - - const auto keyPattern = BSON("a" << 1); - const std::vector<CoreIndexInfo> indexCores = { - CoreIndexInfo(keyPattern, - IndexNames::nameToType(IndexNames::findPluginName(keyPattern)), - false, // sparse - IndexEntry::Identifier{""}, // name - filterExpr.get())}; // filterExpr - - unique_ptr<CanonicalQuery> satisfySinglePredicate(canonicalize("{f: {$eq: 11}}")); - ASSERT_EQ(makeKey(*satisfySinglePredicate, indexCores).getIndexabilityDiscriminators(), "(1)"); - - unique_ptr<CanonicalQuery> satisfyNeither(canonicalize("{f: {$eq: 5}}")); - ASSERT_EQ(makeKey(*satisfyNeither, indexCores).getIndexabilityDiscriminators(), "(0)"); - - unique_ptr<CanonicalQuery> conjSingleFieldMatch(canonicalize("{f: {$lt: 20, $gt: 10}}")); - ASSERT_EQ(makeKey(*conjSingleFieldMatch, indexCores).getIndexabilityDiscriminators(), "(1)"); - - unique_ptr<CanonicalQuery> conjSingleFieldNoMatch(canonicalize("{f: {$gt: 2, $lt: 10}}")); - ASSERT_EQ(makeKey(*conjSingleFieldNoMatch, indexCores).getIndexabilityDiscriminators(), "(0)"); - - unique_ptr<CanonicalQuery> conjSingleFieldOverlap(canonicalize("{f: {$gt: 2, $lt: 12}}")); - ASSERT_EQ(makeKey(*conjSingleFieldOverlap, indexCores).getIndexabilityDiscriminators(), "(0)"); - - // Although this query is technically a subset of the partial filter, the logic to determine - // such ('isSubsetOf' in the code) is conservative in how it compares certain shapes of - // expression trees. - unique_ptr<CanonicalQuery> disjSingleFieldBothSatisfy( - canonicalize("{$or: [{f: {$eq: -1}}, {f: {$gt: 10}}]}")); - ASSERT_EQ(makeKey(*disjSingleFieldBothSatisfy, indexCores).getIndexabilityDiscriminators(), - "(0)"); - - unique_ptr<CanonicalQuery> disjSingleFieldNotSubset( - canonicalize("{$or: [{f: {$eq: 2}}, {f: {$eq: 11}}]}")); - ASSERT_EQ(makeKey(*disjSingleFieldNotSubset, indexCores).getIndexabilityDiscriminators(), - "(0)"); -} - -TEST(PlanCacheKeyInfoTest, ComputeKeyPartialIndexNestedDisjunction) { - BSONObj filterObj = fromjson(R"( - {$and: [ - {$or: [{f: {$gt: 10}}, {f: {$lt: 0}}]}, - {$or: [{f: {$gt: 11}}, {f: {$lt: 1}}]} - ]})"); - unique_ptr<MatchExpression> filterExpr(parseMatchExpression(filterObj)); - - const auto keyPattern = BSON("a" << 1); - const std::vector<CoreIndexInfo> indexCores = { - CoreIndexInfo(keyPattern, - IndexNames::nameToType(IndexNames::findPluginName(keyPattern)), - false, // sparse - IndexEntry::Identifier{""}, // name - filterExpr.get())}; // filterExpr - - - unique_ptr<CanonicalQuery> satisfySinglePredicate(canonicalize("{f: {$eq: 11}}")); - ASSERT_EQ(makeKey(*satisfySinglePredicate, indexCores).getIndexabilityDiscriminators(), "(0)"); - - unique_ptr<CanonicalQuery> notCompat(canonicalize("{f: {$eq: 12}}")); - ASSERT_EQ(makeKey(*notCompat, indexCores).getIndexabilityDiscriminators(), "(1)"); -} - // Query shapes should get the same plan cache key if they have the same collation indexability. TEST(PlanCacheKeyInfoTest, ComputeKeyCollationIndex) { CollatorInterfaceMock collator(CollatorInterfaceMock::MockType::kReverseString); @@ -467,8 +366,8 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyBasedOnPartia // The discriminator strings have the format "<xx>". That is, there are two discriminator // bits for the "x" predicate, the first pertaining to the partialFilterExpression and the // second around applicability to the wildcard index. - ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "(1)<1>"); - ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "(0)<1>"); + ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "<11>"); + ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "<01>"); } // The partialFilterExpression should lead to a discriminator over field 'x', but not over 'y'. @@ -483,8 +382,8 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyBasedOnPartia // The discriminator strings have the format "<xx><y>". That is, there are two discriminator // bits for the "x" predicate (the first pertaining to the partialFilterExpression, the // second around applicability to the wildcard index) and one discriminator bit for "y". - ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "(1)<1><1>"); - ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "(0)<1><1>"); + ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "<11><1>"); + ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "<01><1>"); } // $eq:null predicates cannot be assigned to a wildcard index. Make sure that this is @@ -499,8 +398,8 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyBasedOnPartia // The discriminator strings have the format "<xx><y>". That is, there are two discriminator // bits for the "x" predicate (the first pertaining to the partialFilterExpression, the // second around applicability to the wildcard index) and one discriminator bit for "y". - ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "(1)<1><1>"); - ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "(1)<1><0>"); + ASSERT_EQ(compatibleKey.getIndexabilityDiscriminators(), "<11><1>"); + ASSERT_EQ(incompatibleKey.getIndexabilityDiscriminators(), "<11><0>"); } // Test that the discriminators are correct for an $eq:null predicate on 'x'. This predicate is @@ -509,7 +408,7 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyBasedOnPartia // result in two "0" bits inside the discriminator string. { auto key = makeKey(*canonicalize("{x: {$eq: null}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(0)<0>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<00>"); } } @@ -550,11 +449,11 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyWithPartialFi const std::vector<CoreIndexInfo> indexCores = {indexInfo}; { - // TODO update The discriminators should have the format <xx><yy><z>. The 'z' predicate has - // just one discriminator because it is not referenced in the partial filter expression. All + // The discriminators should have the format <xx><yy><z>. The 'z' predicate has just one + // discriminator because it is not referenced in the partial filter expression. All // predicates are compatible. auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: 2}, z: {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(1)<1><1><1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<11><11><1>"); } { @@ -562,7 +461,7 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyWithPartialFi // compatible with the partial filter expression, leading to one of the 'y' bits being set // to zero. auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: -2}, z: {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(0)<1><1><1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<11><01><1>"); } } @@ -581,20 +480,20 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyDiscriminatesCorrectlyWithPartialFilterAndW // the predicate is compatible with the partial filter expression, whereas the disciminator // for 'y' is about compatibility with the wildcard index. auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: 2}, z: {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(1)<1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<1><1>"); } { // Similar to the previous case, except with an 'x' predicate that is incompatible with the // partial filter expression. auto key = makeKey(*canonicalize("{x: {$eq: -1}, y: {$eq: 2}, z: {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(0)<1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<0><1>"); } { // Case where the 'y' predicate is not compatible with the wildcard index. auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: null}, z: {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(1)<0>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<1><0>"); } } @@ -612,14 +511,14 @@ TEST(PlanCacheKeyInfoTest, ComputeKeyWildcardDiscriminatesCorrectlyWithPartialFi // The discriminators have the format <x><(x.y)(x.y)<y>. All predicates are compatible auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: 2}, 'x.y': {$eq: 3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(1)<1><1><1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<1><11><1>"); } { // Here, the predicate on "x.y" is not compatible with the partial filter expression. auto key = makeKey(*canonicalize("{x: {$eq: 1}, y: {$eq: 2}, 'x.y': {$eq: -3}}"), indexCores); - ASSERT_EQ(key.getIndexabilityDiscriminators(), "(0)<1><1><1>"); + ASSERT_EQ(key.getIndexabilityDiscriminators(), "<1><01><1>"); } } diff --git a/src/mongo/db/query/query_stats/aggregated_metric.h b/src/mongo/db/query/plan_cache_size_parameter.cpp index fca94c3183e..46e42efafbf 100644 --- a/src/mongo/db/query/query_stats/aggregated_metric.h +++ b/src/mongo/db/query/plan_cache_size_parameter.cpp @@ -1,5 +1,5 @@ /** - * Copyright (C) 2023-present MongoDB, Inc. + * Copyright (C) 2021-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, @@ -27,52 +27,48 @@ * it in the license file. */ -#pragma once +#include "mongo/db/query/plan_cache_size_parameter.h" -#include <algorithm> -#include <cstdint> +#include <pcrecpp.h> -#include "mongo/base/string_data.h" -#include "mongo/bson/bsonobjbuilder.h" +#include "mongo/db/query/query_knobs_gen.h" -namespace mongo::query_stats { +namespace mongo::plan_cache_util { -/** - * An aggregated metric stores a compressed view of data. It balances the loss of information - * with the reduction in required storage. - */ -struct AggregatedMetric { +StatusWith<PlanCacheSizeUnits> parseUnitString(const std::string& strUnit) { + if (strUnit.empty()) { + return Status(ErrorCodes::Error{6007010}, "Unit value cannot be empty"); + } - /** - * Aggregate an observed value into the metric. - */ - void aggregate(uint64_t val) { - sum += val; - max = std::max(val, max); - min = std::min(val, min); - sumOfSquares += val * val; + if (strUnit[0] == '%') { + return PlanCacheSizeUnits::kPercent; + } else if (strUnit[0] == 'M' || strUnit[0] == 'm') { + return PlanCacheSizeUnits::kMB; + } else if (strUnit[0] == 'G' || strUnit[0] == 'g') { + return PlanCacheSizeUnits::kGB; } - void appendTo(BSONObjBuilder& builder, const StringData& fieldName) const { - BSONObjBuilder metricsBuilder = builder.subobjStart(fieldName); - metricsBuilder.append("sum", (long long)sum); - metricsBuilder.append("max", (long long)max); - metricsBuilder.append("min", (long long)min); - metricsBuilder.append("sumOfSquares", (long long)sumOfSquares); - metricsBuilder.done(); + return Status(ErrorCodes::Error{6007011}, "Incorrect unit value"); +} + +StatusWith<PlanCacheSizeParameter> PlanCacheSizeParameter::parse(const std::string& str) { + pcrecpp::RE_Options opt; + opt.set_caseless(true); + // Looks for a floating point number with followed by a unit suffix (MB, GB, %). + pcrecpp::RE re("\\s*(\\d+\\.?\\d*)\\s*(MB|GB|%)\\s*", opt); + + double size{}; + std::string strUnit{}; + if (!re.FullMatch(str, &size, &strUnit)) { + return {ErrorCodes::Error{6007012}, "Unable to parse plan cache size string"}; } - uint64_t sum = 0; - // Default to the _signed_ maximum (which fits in unsigned range) because we cast to - // BSONNumeric when serializing. - uint64_t min = (uint64_t)std::numeric_limits<int64_t>::max; - uint64_t max = 0; + auto statusWithUnit = parseUnitString(strUnit); + if (!statusWithUnit.isOK()) { + return statusWithUnit.getStatus(); + } - /** - * The sum of squares along with (an externally stored) count will allow us to compute the - * variance/stddev. - */ - uint64_t sumOfSquares = 0; -}; + return PlanCacheSizeParameter{size, statusWithUnit.getValue()}; +} -} // namespace mongo::query_stats +} // namespace mongo::plan_cache_util diff --git a/src/mongo/db/query/util/memory_util.h b/src/mongo/db/query/plan_cache_size_parameter.h index 345780b4c84..322a1fff564 100644 --- a/src/mongo/db/query/util/memory_util.h +++ b/src/mongo/db/query/plan_cache_size_parameter.h @@ -31,36 +31,29 @@ #include <string> -#include "mongo/base/error_codes.h" #include "mongo/base/status_with.h" -namespace mongo::memory_util { +namespace mongo::plan_cache_util { /** - * Defines units of memory. + * Defines units of planCacheSize parameter. */ -enum class MemoryUnits { +enum class PlanCacheSizeUnits { kPercent, kMB, kGB, }; +StatusWith<PlanCacheSizeUnits> parseUnitString(const std::string& strUnit); + /** - * Represents parsed memory size parameter. + * Represents parsed planCacheSize parameter. */ -struct MemorySize { - static StatusWith<MemorySize> parse(const std::string& str); +struct PlanCacheSizeParameter { + static StatusWith<PlanCacheSizeParameter> parse(const std::string& str); const double size; - const MemoryUnits units; + const PlanCacheSizeUnits units; }; -StatusWith<MemoryUnits> parseUnitString(const std::string& strUnit); -size_t convertToSizeInBytes(const MemorySize& memSize); -size_t capMemorySize(size_t requestedSizeBytes, - size_t maximumSizeGB, - double percentTotalSystemMemory); -size_t getRequestedMemSizeInBytes(const MemorySize& memSize); - - -} // namespace mongo::memory_util +} // namespace mongo::plan_cache_util diff --git a/src/mongo/db/query/plan_cache_size_parameter_test.cpp b/src/mongo/db/query/plan_cache_size_parameter_test.cpp new file mode 100644 index 00000000000..1f0fbf76a27 --- /dev/null +++ b/src/mongo/db/query/plan_cache_size_parameter_test.cpp @@ -0,0 +1,79 @@ +/** + * Copyright (C) 2021-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 "mongo/db/query/plan_cache_size_parameter.h" + +#include "mongo/unittest/unittest.h" + +namespace mongo::plan_cache_util { + +bool operator==(const PlanCacheSizeParameter& lhs, const PlanCacheSizeParameter& rhs) { + constexpr double kEpsilon = 1e-10; + return std::abs(lhs.size - rhs.size) < kEpsilon && lhs.units == rhs.units; +} + +TEST(PlanCacheParameterTest, ParseUnitStringPercent) { + ASSERT_TRUE(PlanCacheSizeUnits::kPercent == parseUnitString("%")); +} + +TEST(PlanCacheParameterTest, ParseUnitStringMB) { + ASSERT_TRUE(PlanCacheSizeUnits::kMB == parseUnitString("MB")); + ASSERT_TRUE(PlanCacheSizeUnits::kMB == parseUnitString("mb")); + ASSERT_TRUE(PlanCacheSizeUnits::kMB == parseUnitString("mB")); + ASSERT_TRUE(PlanCacheSizeUnits::kMB == parseUnitString("Mb")); +} + +TEST(PlanCacheParameterTest, ParseUnitStringGB) { + ASSERT_TRUE(PlanCacheSizeUnits::kGB == parseUnitString("GB")); + ASSERT_TRUE(PlanCacheSizeUnits::kGB == parseUnitString("gb")); + ASSERT_TRUE(PlanCacheSizeUnits::kGB == parseUnitString("gB")); + ASSERT_TRUE(PlanCacheSizeUnits::kGB == parseUnitString("Gb")); +} + +TEST(PlanCacheParameterTest, ParseUnitStringIncorrectValue) { + ASSERT_NOT_OK(parseUnitString("").getStatus()); + ASSERT_NOT_OK(parseUnitString(" ").getStatus()); + ASSERT_NOT_OK(parseUnitString("KB").getStatus()); +} + +TEST(PlanCacheParameterTest, ParsePlanCacheSizeParameter) { + ASSERT_TRUE((PlanCacheSizeParameter{10.0, PlanCacheSizeUnits::kPercent}) == + PlanCacheSizeParameter::parse("10%")); + ASSERT_TRUE((PlanCacheSizeParameter{300.0, PlanCacheSizeUnits::kMB}) == + PlanCacheSizeParameter::parse("300MB")); + ASSERT_TRUE((PlanCacheSizeParameter{4.0, PlanCacheSizeUnits::kGB}) == + PlanCacheSizeParameter::parse("4GB")); + ASSERT_TRUE((PlanCacheSizeParameter{5.1, PlanCacheSizeUnits::kPercent}) == + PlanCacheSizeParameter::parse(" 5.1%")); + ASSERT_TRUE((PlanCacheSizeParameter{11.1, PlanCacheSizeUnits::kMB}) == + PlanCacheSizeParameter::parse("11.1 mb")); + ASSERT_TRUE((PlanCacheSizeParameter{12.1, PlanCacheSizeUnits::kGB}) == + PlanCacheSizeParameter::parse(" 12.1 Gb ")); +} +} // namespace mongo::plan_cache_util diff --git a/src/mongo/db/query/plan_enumerator.cpp b/src/mongo/db/query/plan_enumerator.cpp index 9e30afa0049..a11bc9b415a 100644 --- a/src/mongo/db/query/plan_enumerator.cpp +++ b/src/mongo/db/query/plan_enumerator.cpp @@ -35,7 +35,6 @@ #include "mongo/db/query/index_tag.h" #include "mongo/db/query/indexability.h" -#include "mongo/db/query/query_planner_common.h" #include "mongo/logv2/log.h" #include "mongo/util/string_map.h" @@ -59,8 +58,8 @@ std::string getPathPrefix(std::string path) { * is a predicate that is required to use an index. */ bool expressionRequiresIndex(const MatchExpression* node) { - return QueryPlannerCommon::countNodes(node, MatchExpression::GEO_NEAR) > 0 || - QueryPlannerCommon::countNodes(node, MatchExpression::TEXT) > 0; + return CanonicalQuery::countNodes(node, MatchExpression::GEO_NEAR) > 0 || + CanonicalQuery::countNodes(node, MatchExpression::TEXT) > 0; } size_t getPathLength(const MatchExpression* expr) { @@ -338,8 +337,6 @@ string PlanEnumerator::NodeAssignment::toString() const { str::stream ss; ss << "ALL OF (lockstep): {"; ss << "\n\ttotalEnumerated: " << lockstepOrAssignment->totalEnumerated; - ss << "\n\texhaustedLockstepIteration: " - << lockstepOrAssignment->exhaustedLockstepIteration; ss << "\n\tsubnodes: [ "; for (auto&& node : lockstepOrAssignment->subnodes) { ss << "\n\t\t{"; @@ -1290,8 +1287,6 @@ void PlanEnumerator::getIndexedPreds(MatchExpression* node, std::vector<MatchExpression*>* indexedPreds) { if (Indexability::nodeCanUseIndexOnOwnField(node)) { RelevantTag* rt = static_cast<RelevantTag*>(node->getTag()); - tassert(9074700, "RelevantTag is not assigned to the match expression node", rt != nullptr); - if (context.elemMatchExpr) { // If we're in an $elemMatch context, store the // innermost parent $elemMatch, as well as the @@ -1308,7 +1303,7 @@ void PlanEnumerator::getIndexedPreds(MatchExpression* node, indexedPreds->push_back(node); } else if (Indexability::isBoundsGeneratingNot(node)) { getIndexedPreds(node->getChild(0), context, indexedPreds); - } else if (Indexability::isBoundsGeneratingElemMatchObject(node)) { + } else if (MatchExpression::ELEM_MATCH_OBJECT == node->matchType()) { PrepMemoContext childContext; childContext.elemMatchExpr = node; for (size_t i = 0; i < node->numChildren(); ++i) { @@ -1694,8 +1689,8 @@ bool PlanEnumerator::LockstepOrAssignment::allIdentical() const { return true; } -bool PlanEnumerator::LockstepOrAssignment::shouldResetBeforeProceeding(size_t totalEnumerated, - size_t orLimit) const { +bool PlanEnumerator::LockstepOrAssignment::shouldResetBeforeProceeding( + size_t totalEnumerated) const { if (totalEnumerated == 0 || !exhaustedLockstepIteration) { return false; } @@ -1705,12 +1700,7 @@ bool PlanEnumerator::LockstepOrAssignment::shouldResetBeforeProceeding(size_t to if (!subnode.maxIterCount) { return false; // Haven't yet looped over this child entirely, not ready yet. } - totalPossibleEnumerations *= subnode.maxIterCount.value(); - // If 'totalPossibleEnumerations' reaches the limit, we can just shortcut it. Otherwise, - // 'totalPossibleEnumerations' could overflow if we have a large $or. - if (totalPossibleEnumerations >= orLimit) { - return false; - } + totalPossibleEnumerations *= subnode.maxIterCount.get(); } // If we're able to compute a total number expected enumerations, we must have already cycled @@ -1747,7 +1737,7 @@ bool PlanEnumerator::_nextMemoForLockstepOrAssignment( } // Edge case: if every child has only one option available, we are already finished // enumerating. - if (assignment->shouldResetBeforeProceeding(assignment->totalEnumerated, _orLimit)) { + if (assignment->shouldResetBeforeProceeding(assignment->totalEnumerated)) { assignment->exhaustedLockstepIteration = false; return true; // We're back at the beginning, no need to reset. } @@ -1774,35 +1764,27 @@ bool PlanEnumerator::_nextMemoForLockstepOrAssignment( } }; advanceOnce(); - if (assignment->allIdentical()) { - // All sub-nodes have the same enumeration state, skip this one since we already did it - // above. This is expected to happen pretty often. For example, if we have two subnodes each - // enumerating two states, we'd expect the order to be: 00, 11 (these two iterated above), - // then 00 (skipped here when we fall through after finishing lockstep iteration), then 10, - // 01, then finally 11 (skipped here). - // - // In this example, when we finally roll back to 00, enumeration is complete. We will fall - // through the code below which is responsible for resetting all enumeration state to the - // starting point (which need not reset the child nodes in this case because they already - // all rolled back to the starting point of 00). Finally, we return true to indicate that - // all possibilities have been enumerated. + while (assignment->allIdentical()) { + // All sub-nodes have the same enumeration state, skip this one since we already did + // it above. This is expected to happen pretty often. For example, if we have two subnodes + // each enumerating two states, we'd expect the order to be: 00, 11 (these two iterated + // above), then 00 (skipped by falling through above after finishing lockstep iteration), + // then 10, 11 (skipped here), 00 (skipped here), then finally 01. advanceOnce(); } // This special ordering is tricky to reset. Because it iterates the sub nodes in such a // unique order, it can be difficult to know when it has actually finished iterating. Our // strategy is just to compute a total and go back to the beginning once we hit that total. - if (!assignment->shouldResetBeforeProceeding(assignment->totalEnumerated, _orLimit)) { + if (!assignment->shouldResetBeforeProceeding(assignment->totalEnumerated)) { return false; } // Reset! for (auto&& subnode : assignment->subnodes) { - if (subnode.iterationCount != 0) { - while (!nextMemo(subnode.memoId)) { - // Keep advancing till it rolls over. - } - subnode.iterationCount = 0; + while (!nextMemo(subnode.memoId)) { + // Keep advancing till it rolls over. } + subnode.iterationCount = 0; } assignment->exhaustedLockstepIteration = false; return true; diff --git a/src/mongo/db/query/plan_enumerator.h b/src/mongo/db/query/plan_enumerator.h index b82b738c57b..60344f0c9ee 100644 --- a/src/mongo/db/query/plan_enumerator.h +++ b/src/mongo/db/query/plan_enumerator.h @@ -244,7 +244,7 @@ private: * Returns true if 'totalEnumerated' matches the total number of expected plans for this * assignment. */ - bool shouldResetBeforeProceeding(size_t totalEnumerated, size_t orLimit) const; + bool shouldResetBeforeProceeding(size_t totalEnumerated) const; /** * Returns true if each sub node is at the same iterationCount. diff --git a/src/mongo/db/query/plan_executor.cpp b/src/mongo/db/query/plan_executor.cpp index 99b2fd8fefa..ee41d15d84c 100644 --- a/src/mongo/db/query/plan_executor.cpp +++ b/src/mongo/db/query/plan_executor.cpp @@ -38,10 +38,6 @@ namespace { MONGO_FAIL_POINT_DEFINE(planExecutorAlwaysFails); } // namespace -const OperationContext::Decoration<boost::optional<SharedSemiFuture<void>>> - planExecutorShardingCriticalSectionFuture = - OperationContext::declareDecoration<boost::optional<SharedSemiFuture<void>>>(); - std::string PlanExecutor::stateToStr(ExecState execState) { switch (execState) { case PlanExecutor::ADVANCED: diff --git a/src/mongo/db/query/plan_executor.h b/src/mongo/db/query/plan_executor.h index 30ba3d69c63..33fbd075b93 100644 --- a/src/mongo/db/query/plan_executor.h +++ b/src/mongo/db/query/plan_executor.h @@ -52,21 +52,8 @@ class RecordId; * 'clientsLastKnownCommittedOpTime' represents the time passed to the getMore command. * If the replication coordinator ever reports a higher committed op time, we should stop waiting * for inserts and return immediately to speed up the propagation of commit level changes. - * - * A boost::none value opts out of the commit point propagation. A null optime compares less than - * any non-null optimes and thus will always trigger an empty batch for commit point propagation. - */ -extern const OperationContext::Decoration<boost::optional<repl::OpTime>> - clientsLastKnownCommittedOpTime; - -/** - * If a plan yielded because it encountered a sharding critical section, - * 'planExecutorShardingCriticalSectionFuture' will be set to a future that becomes ready when the - * critical section ends. This future can be waited on to hold off resuming the plan execution while - * the critical section is still active. */ -extern const OperationContext::Decoration<boost::optional<SharedSemiFuture<void>>> - planExecutorShardingCriticalSectionFuture; +extern const OperationContext::Decoration<repl::OpTime> clientsLastKnownCommittedOpTime; /** * A PlanExecutor is the abstraction that knows how to crank a tree of stages into execution. diff --git a/src/mongo/db/query/plan_executor_factory.cpp b/src/mongo/db/query/plan_executor_factory.cpp index 386bf38a538..0b66c3dafce 100644 --- a/src/mongo/db/query/plan_executor_factory.cpp +++ b/src/mongo/db/query/plan_executor_factory.cpp @@ -31,8 +31,6 @@ #include "mongo/platform/basic.h" -#include <iostream> - #include "mongo/db/query/plan_executor_factory.h" #include "mongo/db/exec/plan_stage.h" @@ -42,7 +40,6 @@ #include "mongo/db/query/query_planner_params.h" #include "mongo/db/query/util/make_data_structure.h" #include "mongo/logv2/log.h" -#include "mongo/util/duration.h" namespace mongo::plan_executor_factory { @@ -68,7 +65,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( yieldPolicy); } - StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( const boost::intrusive_ptr<ExpressionContext>& expCtx, std::unique_ptr<WorkingSet> ws, @@ -78,7 +74,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( size_t plannerOptions, NamespaceString nss, std::unique_ptr<QuerySolution> qs) { - return make(expCtx->opCtx, std::move(ws), std::move(rt), @@ -103,7 +98,6 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( NamespaceString nss, PlanYieldPolicy::YieldPolicy yieldPolicy) { dassert(collection); - try { auto execImpl = new PlanExecutorImpl(opCtx, std::move(ws), @@ -134,6 +128,7 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( NamespaceString nss, std::unique_ptr<PlanYieldPolicySBE> yieldPolicy) { auto&& [rootStage, data] = root; + LOGV2_DEBUG(4822860, 5, "SBE plan", @@ -162,6 +157,7 @@ StatusWith<std::unique_ptr<PlanExecutor, PlanExecutor::Deleter>> make( size_t plannerOptions, NamespaceString nss, std::unique_ptr<PlanYieldPolicySBE> yieldPolicy) { + LOGV2_DEBUG(4822861, 5, "SBE plan", diff --git a/src/mongo/db/query/plan_executor_factory.h b/src/mongo/db/query/plan_executor_factory.h index df7184583ec..bf41f169af9 100644 --- a/src/mongo/db/query/plan_executor_factory.h +++ b/src/mongo/db/query/plan_executor_factory.h @@ -29,7 +29,6 @@ #pragma once -#include "mongo/util/duration.h" #include <queue> #include "mongo/db/exec/sbe/stages/stages.h" diff --git a/src/mongo/db/query/plan_executor_impl.cpp b/src/mongo/db/query/plan_executor_impl.cpp index ae40ecd070e..6691a52fb8a 100644 --- a/src/mongo/db/query/plan_executor_impl.cpp +++ b/src/mongo/db/query/plan_executor_impl.cpp @@ -33,12 +33,10 @@ #include "mongo/db/query/plan_executor_impl.h" -#include "mongo/util/duration.h" #include <memory> #include "mongo/bson/simple_bsonobj_comparator.h" #include "mongo/db/catalog/collection.h" -#include "mongo/db/concurrency/exception_util.h" #include "mongo/db/concurrency/write_conflict_exception.h" #include "mongo/db/curop.h" #include "mongo/db/exec/cached_plan.h" @@ -63,7 +61,6 @@ #include "mongo/db/query/plan_yield_policy_impl.h" #include "mongo/db/query/yield_policy_callbacks_impl.h" #include "mongo/db/repl/replication_coordinator.h" -#include "mongo/db/s/operation_sharding_state.h" #include "mongo/db/service_context.h" #include "mongo/logv2/log.h" #include "mongo/util/fail_point.h" @@ -77,8 +74,8 @@ using std::string; using std::unique_ptr; using std::vector; -const OperationContext::Decoration<boost::optional<repl::OpTime>> clientsLastKnownCommittedOpTime = - OperationContext::declareDecoration<boost::optional<repl::OpTime>>(); +const OperationContext::Decoration<repl::OpTime> clientsLastKnownCommittedOpTime = + OperationContext::declareDecoration<repl::OpTime>(); // This failpoint is also accessed by the SBE executor so we define it outside of an anonymous // namespace. @@ -103,11 +100,11 @@ std::unique_ptr<PlanYieldPolicy> makeYieldPolicy(PlanExecutorImpl* exec, } case PlanYieldPolicy::YieldPolicy::ALWAYS_TIME_OUT: { return std::make_unique<AlwaysTimeOutYieldPolicy>( - exec->getOpCtx(), exec->getOpCtx()->getServiceContext()->getFastClockSource()); + exec->getOpCtx()->getServiceContext()->getFastClockSource()); } case PlanYieldPolicy::YieldPolicy::ALWAYS_MARK_KILLED: { return std::make_unique<AlwaysPlanKilledYieldPolicy>( - exec->getOpCtx(), exec->getOpCtx()->getServiceContext()->getFastClockSource()); + exec->getOpCtx()->getServiceContext()->getFastClockSource()); } default: MONGO_UNREACHABLE; @@ -137,6 +134,13 @@ PlanExecutorImpl::PlanExecutorImpl(OperationContext* opCtx, invariant(!_expCtx || _expCtx->opCtx == _opCtx); invariant(!_cq || !_expCtx || _cq->getExpCtx() == _expCtx); + // If this PlanExecutor is executing a COLLSCAN, keep a pointer directly to the COLLSCAN + // stage. This is used for change streams in order to keep the the latest oplog timestamp + // and post batch resume token up to date as the oplog scan progresses. + if (auto collectionScan = getStageByType(_root.get(), STAGE_COLLSCAN)) { + _collScanStage = static_cast<CollectionScan*>(collectionScan); + } + // If we don't yet have a namespace string, then initialize it from either 'collection' or // '_cq'. if (_nss.isEmpty()) { @@ -168,13 +172,6 @@ PlanExecutorImpl::PlanExecutorImpl(OperationContext* opCtx, _planExplainer->updateEnumeratorExplainInfo( subplanStage->compositeSolution()->_enumeratorExplainInfo); } - - // If this PlanExecutor is executing a COLLSCAN, keep a pointer directly to the COLLSCAN - // stage. This is used for change streams in order to keep the the latest oplog timestamp - // and post batch resume token up to date as the oplog scan progresses. - if (auto collectionScan = getStageByType(_root.get(), STAGE_COLLSCAN)) { - _collScanStage = static_cast<CollectionScan*>(collectionScan); - } } Status PlanExecutorImpl::_pickBestPlan() { @@ -362,25 +359,8 @@ PlanExecutor::ExecState PlanExecutorImpl::_getNextImpl(Snapshotted<Document>* ob // 2) some stage requested a yield, or // 3) we need to yield and retry due to a WriteConflictException. // In all cases, the actual yielding happens here. - - const auto whileYieldingFn = [&]() { - // If we yielded because we encountered a sharding critical section, wait for the - // critical section to end before continuing. By waiting for the critical section to be - // exited we avoid busy spinning immediately and encountering the same critical section - // again. It is important that this wait happens after having released the lock - // hierarchy -- otherwise deadlocks could happen, or the very least, locks would be - // unnecessarily held while waiting. - const auto& shardingCriticalSection = planExecutorShardingCriticalSectionFuture(_opCtx); - if (shardingCriticalSection) { - OperationShardingState::waitForCriticalSectionToComplete(_opCtx, - *shardingCriticalSection) - .ignore(); - planExecutorShardingCriticalSectionFuture(_opCtx).reset(); - } - }; - if (_yieldPolicy->shouldYieldOrInterrupt(_opCtx)) { - uassertStatusOK(_yieldPolicy->yieldOrInterrupt(_opCtx, whileYieldingFn)); + uassertStatusOK(_yieldPolicy->yieldOrInterrupt(_opCtx)); } WorkingSetID id = WorkingSet::INVALID_ID; @@ -447,7 +427,8 @@ PlanExecutor::ExecState PlanExecutorImpl::_getNextImpl(Snapshotted<Document>* ob CurOp::get(_opCtx)->debug().additiveMetrics.incrementWriteConflicts(1); writeConflictsInARow++; - logWriteConflictAndBackoff(writeConflictsInARow, "plan execution", _nss.ns()); + WriteConflictException::logAndBackoff( + writeConflictsInARow, "plan execution", _nss.ns()); // If we're allowed to, we will yield next time through the loop. if (_yieldPolicy->canAutoYield()) { diff --git a/src/mongo/db/query/plan_executor_impl.h b/src/mongo/db/query/plan_executor_impl.h index ac593cd710c..672cd75f243 100644 --- a/src/mongo/db/query/plan_executor_impl.h +++ b/src/mongo/db/query/plan_executor_impl.h @@ -29,7 +29,6 @@ #pragma once -#include "mongo/util/duration.h" #include <boost/optional.hpp> #include <queue> diff --git a/src/mongo/db/query/plan_executor_sbe.cpp b/src/mongo/db/query/plan_executor_sbe.cpp index e1909acf95c..c8d516cb718 100644 --- a/src/mongo/db/query/plan_executor_sbe.cpp +++ b/src/mongo/db/query/plan_executor_sbe.cpp @@ -41,7 +41,6 @@ #include "mongo/db/query/sbe_stage_builder.h" #include "mongo/logv2/log.h" #include "mongo/s/resharding/resume_token_gen.h" -#include "mongo/util/duration.h" namespace mongo { // This failpoint is defined by the classic executor but is also accessed here. diff --git a/src/mongo/db/query/plan_executor_sbe.h b/src/mongo/db/query/plan_executor_sbe.h index c11d97392ee..547f0fb0a07 100644 --- a/src/mongo/db/query/plan_executor_sbe.h +++ b/src/mongo/db/query/plan_executor_sbe.h @@ -29,7 +29,6 @@ #pragma once -#include "mongo/util/duration.h" #include <queue> #include "mongo/db/exec/sbe/stages/stages.h" diff --git a/src/mongo/db/query/plan_explainer.h b/src/mongo/db/query/plan_explainer.h index ffaabecc43a..b53a10e5655 100644 --- a/src/mongo/db/query/plan_explainer.h +++ b/src/mongo/db/query/plan_explainer.h @@ -29,14 +29,12 @@ #pragma once -#include "mongo/bson/bsonobj.h" #include "mongo/db/exec/plan_stats.h" #include "mongo/db/query/classic_plan_cache.h" #include "mongo/db/query/explain_options.h" #include "mongo/db/query/plan_enumerator_explain_info.h" #include "mongo/db/query/plan_summary_stats.h" #include "mongo/db/query/query_solution.h" -#include "mongo/util/duration.h" namespace mongo { /** diff --git a/src/mongo/db/query/plan_explainer_factory.cpp b/src/mongo/db/query/plan_explainer_factory.cpp index 9307ec349f6..544ab33fdd2 100644 --- a/src/mongo/db/query/plan_explainer_factory.cpp +++ b/src/mongo/db/query/plan_explainer_factory.cpp @@ -34,8 +34,6 @@ #include "mongo/db/exec/plan_cache_util.h" #include "mongo/db/query/plan_explainer_impl.h" #include "mongo/db/query/plan_explainer_sbe.h" -#include "mongo/util/duration.h" -#include <ratio> namespace mongo::plan_explainer_factory { std::unique_ptr<PlanExplainer> make(PlanStage* root) { diff --git a/src/mongo/db/query/plan_explainer_factory.h b/src/mongo/db/query/plan_explainer_factory.h index 0064df7cb39..5e24a755747 100644 --- a/src/mongo/db/query/plan_explainer_factory.h +++ b/src/mongo/db/query/plan_explainer_factory.h @@ -36,7 +36,6 @@ #include "mongo/db/query/plan_explainer.h" #include "mongo/db/query/query_solution.h" #include "mongo/db/query/sbe_plan_ranker.h" -#include "mongo/util/duration.h" namespace mongo::plan_explainer_factory { std::unique_ptr<PlanExplainer> make(PlanStage* root); diff --git a/src/mongo/db/query/plan_explainer_impl.cpp b/src/mongo/db/query/plan_explainer_impl.cpp index a67c9e98a60..1e34cf73ebe 100644 --- a/src/mongo/db/query/plan_explainer_impl.cpp +++ b/src/mongo/db/query/plan_explainer_impl.cpp @@ -655,6 +655,7 @@ boost::optional<double> getWinningPlanScore(PlanStage* root) { void PlanExplainerImpl::getSummaryStats(PlanSummaryStats* statsOut) const { invariant(statsOut); + // We can get some of the fields we need from the common stats stored in the // root stage of the plan tree. const CommonStats* common = _root->getCommonStats(); @@ -667,9 +668,6 @@ void PlanExplainerImpl::getSummaryStats(PlanSummaryStats* statsOut) const { statsOut->totalKeysExamined = 0; statsOut->totalDocsExamined = 0; - statsOut->indexesUsed.clear(); - statsOut->collectionScans = 0; - statsOut->collectionScansNonTailable = 0; for (size_t i = 0; i < stages.size(); i++) { statsOut->totalKeysExamined += diff --git a/src/mongo/db/query/plan_explainer_impl.h b/src/mongo/db/query/plan_explainer_impl.h index f73a2ec6250..73ef81ae825 100644 --- a/src/mongo/db/query/plan_explainer_impl.h +++ b/src/mongo/db/query/plan_explainer_impl.h @@ -29,12 +29,10 @@ #pragma once -#include "mongo/bson/bsonobj.h" #include "mongo/db/exec/plan_stage.h" #include "mongo/db/query/plan_enumerator_explain_info.h" #include "mongo/db/query/plan_explainer.h" #include "mongo/db/query/query_solution.h" -#include "mongo/util/duration.h" namespace mongo { /** @@ -49,6 +47,7 @@ public: PlanExplainerImpl(PlanStage* root, const PlanEnumeratorExplainInfo& explainInfo) : PlanExplainer{explainInfo}, _root{root} {} PlanExplainerImpl(PlanStage* root) : _root{root} {} + const ExplainVersion& getVersion() const final; bool isMultiPlan() const final; std::string getPlanSummary() const final; diff --git a/src/mongo/db/query/plan_explainer_sbe.cpp b/src/mongo/db/query/plan_explainer_sbe.cpp index 25ef5435572..2f8f5b43b08 100644 --- a/src/mongo/db/query/plan_explainer_sbe.cpp +++ b/src/mongo/db/query/plan_explainer_sbe.cpp @@ -371,10 +371,9 @@ void PlanExplainerSBE::getSummaryStats(PlanSummaryStats* statsOut) const { // Use the pre-computed summary stats instead of traversing the QuerySolution tree. const auto& indexesUsed = _debugInfo->mainStats.indexesUsed; - statsOut->indexesUsed.clear(); statsOut->indexesUsed.insert(indexesUsed.begin(), indexesUsed.end()); - statsOut->collectionScans = _debugInfo->mainStats.collectionScans; - statsOut->collectionScansNonTailable = _debugInfo->mainStats.collectionScansNonTailable; + statsOut->collectionScans += _debugInfo->mainStats.collectionScans; + statsOut->collectionScansNonTailable += _debugInfo->mainStats.collectionScansNonTailable; } void PlanExplainerSBE::getSecondarySummaryStats(std::string secondaryColl, diff --git a/src/mongo/db/query/plan_explainer_sbe.h b/src/mongo/db/query/plan_explainer_sbe.h index a256e1371c6..5dc97f90641 100644 --- a/src/mongo/db/query/plan_explainer_sbe.h +++ b/src/mongo/db/query/plan_explainer_sbe.h @@ -35,7 +35,6 @@ #include "mongo/db/query/plan_explainer.h" #include "mongo/db/query/query_solution.h" #include "mongo/db/query/sbe_plan_ranker.h" -#include "mongo/util/duration.h" namespace mongo { /** diff --git a/src/mongo/db/query/plan_insert_listener.cpp b/src/mongo/db/query/plan_insert_listener.cpp index 1b7270eef76..0d86c76c9e7 100644 --- a/src/mongo/db/query/plan_insert_listener.cpp +++ b/src/mongo/db/query/plan_insert_listener.cpp @@ -65,10 +65,9 @@ bool shouldWaitForInserts(OperationContext* opCtx, // coordinator's lastCommittedOpTime has progressed past the client's lastCommittedOpTime. // In that case, we will return early so that we can inform the client of the new // lastCommittedOpTime immediately. - if (clientsLastKnownCommittedOpTime(opCtx)) { + if (!clientsLastKnownCommittedOpTime(opCtx).isNull()) { auto replCoord = repl::ReplicationCoordinator::get(opCtx); - return clientsLastKnownCommittedOpTime(opCtx).value() >= - replCoord->getLastCommittedOpTime(); + return clientsLastKnownCommittedOpTime(opCtx) >= replCoord->getLastCommittedOpTime(); } return true; } diff --git a/src/mongo/db/query/plan_ranker.cpp b/src/mongo/db/query/plan_ranker.cpp index 42fb5645ff8..87f189e89f7 100644 --- a/src/mongo/db/query/plan_ranker.cpp +++ b/src/mongo/db/query/plan_ranker.cpp @@ -93,21 +93,6 @@ void logFailedPlan(std::function<std::string()> planSummary) { LOGV2_DEBUG( 20960, 2, "Not scoring a plan because the plan failed", "planSummary"_attr = planSummary()); } - -void logTieBreaking(double score, - double docsExaminedBonus, - double indexPrefixBonus, - bool isPlanTied) { - LOGV2_DEBUG(8027500, 2, "Tie breaking heuristics", "formula"_attr = [&]() { - StringBuilder sb; - sb << "isPlanTied: " << isPlanTied << ". finalScore(" - << str::convertDoubleToString(score + docsExaminedBonus + indexPrefixBonus) - << ") = score(" << str::convertDoubleToString(score) << ") + docsExaminedBonus(" - << str::convertDoubleToString(docsExaminedBonus) << ") + indexPrefixBonus(" - << str::convertDoubleToString(indexPrefixBonus) << ")"; - return sb.str(); - }()); -} } // namespace log_detail namespace { @@ -153,296 +138,9 @@ protected: return false; } }; - -/** - * Return true if the nodes have the same type and the same number of children. - */ -bool areNodesCompatible(const std::vector<const QuerySolutionNode*>& nodes) { - for (size_t i = 1; i < nodes.size(); ++i) { - if (nodes[i - 1]->getType() != nodes[i]->getType()) { - return false; - } - - if (nodes[i - 1]->children.size() != nodes[i]->children.size()) { - return false; - } - } - - return true; -} - -/** - * Returns true if the value can serve as a type lower bound for the purposes of type bracketing. - * The function is designed to work with the 'interesting' for index prefix heuristic types only: - * Number, String, Date, Timestamp, Boolean, Object, Array, ObjectId. For other types it may return - * false positive results. The code of the function is based on index bounds build logic from - * 'index_bounds_builder.cpp'. - */ -bool isLowerBound(const BSONElement& value, bool isInclusive) { - switch (value.type()) { - case NumberInt: - case NumberDouble: - case NumberLong: - case NumberDecimal: - // Lower bound value for numbers. - return (std::isinf(value.numberDouble()) || std::isnan(value.numberDouble())) && - isInclusive == true; - case String: - // Lower bound value for strings. - return value.str().empty() && isInclusive == true; - case Date: - // Lower bound value for dates. - return value.date() == Date_t::min() && isInclusive == true; - case bsonTimestamp: - // Lower bound value for timestamps. - return value.timestamp() == Timestamp::min() && isInclusive == true; - case jstOID: - // Lower bound value for ObjectID. - return value.OID() == OID() && isInclusive == true; - case Object: - case Array: - // Lower bound value for Object and Array. - return value.Obj().isEmpty() && isInclusive == true; - case BinData: - case EOO: - case MinKey: - case MaxKey: - case Bool: // Boolean bounds are considered always open since they are non-selective. - case jstNULL: - case Undefined: - case Symbol: - case RegEx: - case DBRef: - case Code: - case CodeWScope: - return true; - } - - MONGO_UNREACHABLE_TASSERT(8102100); -} - -/** - * Returns true if the value can serve as a type upper bound for the purposes of type bracketing. - * The function is designed to work with the 'interesting' for index prefix heuristic types only: - * Number, String, Date, Timestamp, Boolean, Object, Array, ObjectId. For other types it may return - * false positive results. The code of the function is based on index bounds build logic from - * 'index_bounds_builder.cpp'. - */ -bool isUpperBound(const BSONElement& value, bool isInclusive) { - switch (value.type()) { - case NumberInt: - case NumberDouble: - case NumberLong: - case NumberDecimal: - // Upper bound value for numbers. - return std::isinf(value.numberDouble()) && isInclusive == true; - case String: - // A string value cannot be an upper bound value. - return false; - case Date: - // Upper bound value for Date. - return value.date() == Date_t::max() && isInclusive == true; - case bsonTimestamp: - // Upper bound value for Timestamp. - return value.timestamp() == Timestamp::max() && isInclusive == true; - case jstOID: - // Upper bound value for ObjectID. - return value.OID() == OID::max() && isInclusive == true; - case Object: - // Upper bound value for String. - return value.Obj().isEmpty() && isInclusive == false; - case Array: - // Upper bound value for Object. - return value.Obj().isEmpty() && isInclusive == false; - case BinData: - // Upper bound value for Array. - return value.valuesize() == 0 && isInclusive == false; - case EOO: - case MinKey: - case MaxKey: - case Bool: // Boolean bounds are considered always open since they are non-selective. - case jstNULL: - case Undefined: - case Symbol: - case RegEx: - case DBRef: - case Code: - case CodeWScope: - return true; - } - - MONGO_UNREACHABLE_TASSERT(8102101); -} - -/** - * The function tries to detect if the interval is closed on both ends. Can return false - * positive results for the types not mentioned in the comment to 'isMinMaxValue' function. - */ -bool isClosedInterval(const Interval& interval) { - // If the bound types are different the interval is considered to be open. - if (interval.start.type() != interval.end.type()) { - return false; - } - - switch (interval.getDirection()) { - // Point intervals, empty intervals, and null intervals have no direction. - case Interval::Direction::kDirectionNone: - return true; - case Interval::Direction::kDirectionAscending: - return !isLowerBound(interval.start, interval.startInclusive) && - !isUpperBound(interval.end, interval.endInclusive); - case Interval::Direction::kDirectionDescending: - return !isUpperBound(interval.start, interval.startInclusive) && - !isLowerBound(interval.end, interval.endInclusive); - } - - MONGO_UNREACHABLE_TASSERT(8102102); -} - -/** - * Returns true if this OIL contains only closed intervals. - */ -bool containsOnlyClosedIntervals(const OrderedIntervalList& oil) { - for (const auto& interval : oil.intervals) { - if (!isClosedInterval(interval)) { - return false; - } - } - - return true; -} - -/** - * Calculates score for the given index bounds. The score reflects the following rules: - * - IndexBounds that has longest single point interval prefix wins, - * - if winner is not defined on the previous step then IndexBounds with the longest point - * interval prefix wins, - * - if winner is not defined on the previous step then IndexBounds with the longest closed - * interval prefix wins, - * - if winner is not defined, then IndexBounds with longest interval prefix wins - * - if winner is not defined, them IndexBounds with shortest index key pattern wins. - */ -uint64_t getIndexBoundsScore(const IndexBounds& bounds) { - const uint64_t indexKeyLength = static_cast<uint64_t>(bounds.fields.size()); - uint64_t singlePointIntervalPrefix = 0; - uint64_t pointsIntervalPrefix = 0; - uint64_t closedIntervalPrefix = 0; - uint64_t intervalLength = 0; - - for (const auto& field : bounds.fields) { - // Skip the $** index virtual field, as it's not part of the actual index key. - if (field.name == "$_path") { - continue; - } - - // Stop scoring index bounds as soon as we see an all-values interval. - if (field.isMinToMax() || field.isMaxToMin()) { - break; - } - - if (intervalLength == singlePointIntervalPrefix && field.isPoint()) { - ++singlePointIntervalPrefix; - } - - if (intervalLength == pointsIntervalPrefix && field.containsOnlyPointIntervals()) { - ++pointsIntervalPrefix; - } - - if (intervalLength == closedIntervalPrefix && containsOnlyClosedIntervals(field)) { - ++closedIntervalPrefix; - } - - ++intervalLength; - } - - // We pack calculated stats into one value to make their comparison simplier. For every - // prefix length we allocate 12 bits (4096 values) which is more then enough since an index - // can have no more than 32 fields (see "MongoDB Limits and Thresholds" reference). - // 'indexKeyLength' is treated differently because, unlike others, we prefer shorter index - // key prefix length (see the comment to the function for details). - uint64_t result = (singlePointIntervalPrefix << 52) | (pointsIntervalPrefix << 40) | - (closedIntervalPrefix << 28) | (intervalLength << 16) | - (std::numeric_limits<uint16_t>::max() - indexKeyLength); - - return result; -} - -/** - * Calculates scores for the given IndexBounds and add 1 to every winner's resultScores. i-th - * position in resultScores corresponds to i-th field in IndexBound. - */ -void scoreIndexBounds(const std::vector<const IndexBounds*>& bounds, - std::vector<size_t>& resultScores) { - const size_t nfields = bounds.size(); - - std::vector<uint64_t> scores{}; - scores.reserve(nfields); - for (size_t i = 0; i < bounds.size(); ++i) { - scores.emplace_back(getIndexBoundsScore(*bounds[i])); - } - - auto topScore = max_element(scores.begin(), scores.end()); - for (size_t i = 0; i < nfields; ++i) { - if (*topScore == scores[i]) { - resultScores[i] += 1; - } - } -} } // namespace std::unique_ptr<PlanScorer<PlanStageStats>> makePlanScorer() { return std::make_unique<DefaultPlanScorer>(); } - -std::vector<size_t> applyIndexPrefixHeuristic(const std::vector<const QuerySolution*>& solutions) { - std::vector<size_t> solutionScores(solutions.size(), 0); - - std::vector<std::vector<const QuerySolutionNode*>> stack{}; - stack.emplace_back(); - stack.back().reserve(solutions.size()); - for (auto solution : solutions) { - stack.back().emplace_back(solution->root()); - } - - while (!stack.empty()) { - auto top = std::move(stack.back()); - stack.pop_back(); - - if (!areNodesCompatible(top)) { - return {}; - } - - // Compatible nodes have the same number of children, see comment to 'areNodesCompatible' - // function. - for (size_t childIndex = 0; childIndex < top.front()->children.size(); ++childIndex) { - stack.emplace_back(); - stack.back().reserve(solutions.size()); - for (auto node : top) { - stack.back().emplace_back(node->children[childIndex]); - } - } - - if (top.front()->getType() == STAGE_IXSCAN) { - std::vector<const IndexBounds*> bounds{}; - bounds.reserve(solutions.size()); - - for (auto node : top) { - bounds.emplace_back(&static_cast<const IndexScanNode*>(node)->bounds); - } - - scoreIndexBounds(bounds, solutionScores); - } - } - - std::vector<size_t> winningSolutionIndices{}; - winningSolutionIndices.reserve(solutions.size()); - const auto topScore = max_element(solutionScores.begin(), solutionScores.end()); - for (size_t index = 0; index < solutionScores.size(); ++index) { - if (solutionScores[index] == *topScore) { - winningSolutionIndices.emplace_back(index); - } - } - - return winningSolutionIndices; -} } // namespace mongo::plan_ranker diff --git a/src/mongo/db/query/plan_ranker.h b/src/mongo/db/query/plan_ranker.h index c9c7baf46b1..8a6a2c18ad9 100644 --- a/src/mongo/db/query/plan_ranker.h +++ b/src/mongo/db/query/plan_ranker.h @@ -65,15 +65,8 @@ void logScoringPlan(std::function<std::string()> solution, void logScore(double score); void logEOFBonus(double eofBonus); void logFailedPlan(std::function<std::string()> planSummary); -void logTieBreaking(double score, - double docsFetchedBonus, - double indexPrefixBonus, - bool isPlanTied); } // namespace log_detail -// Constant used for tie breakers. -const double kBonusEpsilon = 1e-4; - /** * Assigns the stats tree a 'goodness' score. The higher the score, the better the plan. The exact * value isn't meaningful except for imposing a ranking. @@ -96,7 +89,7 @@ public: const auto productivity = calculateProductivity(stats); const auto advances = getNumberOfAdvances(stats); const double epsilon = - std::min(1.0 / static_cast<double>(10 * (advances > 0 ? advances : 1)), kBonusEpsilon); + std::min(1.0 / static_cast<double>(10 * (advances > 0 ? advances : 1)), 1e-4); // We prefer queries that don't require a fetch stage. @@ -206,11 +199,4 @@ struct BaseCandidatePlan { }; using CandidatePlan = BaseCandidatePlan<PlanStage*, WorkingSetID, WorkingSet*>; - -/** - * Apply index prefix heuristic (see comment to 'getIndexBoundsScore' function in the cpp file) for - * the given list of solutions, if the solutions are compatible (have the same plan shape), the - * vector of winner indexes are returned, otherwise an empty vector is returned. - */ -std::vector<size_t> applyIndexPrefixHeuristic(const std::vector<const QuerySolution*>& solutions); } // namespace mongo::plan_ranker diff --git a/src/mongo/db/query/plan_ranker_index_prefix_test.cpp b/src/mongo/db/query/plan_ranker_index_prefix_test.cpp deleted file mode 100644 index ae3a5455863..00000000000 --- a/src/mongo/db/query/plan_ranker_index_prefix_test.cpp +++ /dev/null @@ -1,422 +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. - */ - -/** - * This file contains tests for mongo/db/query/plan_ranker.h - */ - -#include "mongo/db/query/plan_ranker.h" - -#include "mongo/unittest/unittest.h" - -namespace mongo::plan_ranker { -namespace { -IndexEntry buildSimpleIndexEntry(const BSONObj& kp) { - return {kp, - IndexNames::nameToType(IndexNames::findPluginName(kp)), - IndexDescriptor::kLatestIndexVersion, - false, - {}, - {}, - false, - false, - CoreIndexInfo::Identifier("test_foo"), - nullptr, - {}, - nullptr, - nullptr}; -} - -OrderedIntervalList makeOIL(const std::string& fieldName, - std::initializer_list<BSONObj> intervals) { - OrderedIntervalList oil(fieldName); - for (auto&& interval : intervals) { - oil.intervals.emplace_back(std::move(interval), true, true); - } - return oil; -} - -std::unique_ptr<QuerySolution> makeSolution(std::unique_ptr<QuerySolutionNode> child) { - auto solution = std::make_unique<QuerySolution>(); - solution->setRoot(std::make_unique<FetchNode>(std::move(child))); - return solution; -} - -std::unique_ptr<IndexScanNode> makeIndexScan( - BSONObj indexKey, std::initializer_list<OrderedIntervalList> indexBoundsFields) { - IndexBounds bounds{}; - for (auto&& field : indexBoundsFields) { - bounds.fields.emplace_back(std::move(field)); - } - - auto indexScan = std::make_unique<IndexScanNode>(buildSimpleIndexEntry(indexKey)); - indexScan->bounds = std::move(bounds); - indexScan->computeProperties(); - - return indexScan; -} -} // namespace - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_LongerSinglePointPrefixWins) { - // a: [[1, 1]]; b: [[1, 3]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 1 << "" << 1)}), - makeOIL("b", {BSON("" << 1 << "" << 3)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[1, 1]]; d: [[1, 1]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 1 << "" << 1)}), - makeOIL("d", {BSON("" << 1 << "" << 1)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - // e: [[1, 1]]; f: [[2, 2], [3, 3]]; g: [[4, 4]] - auto indexScan3 = - makeIndexScan(BSON("e" << 1 << "f" << 1 << "g" << 1), - { - makeOIL("e", {BSON("" << 1 << "" << 1)}), - makeOIL("f", {BSON("" << 2 << "" << 2), BSON("" << 3 << "" << 3)}), - makeOIL("g", {BSON("" << 4 << "" << 4)}), - }); - auto solution3 = makeSolution(std::move(indexScan3)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get(), solution3.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_LongerPointPrefixWins) { - // a: [[1, 1], [2, 2]]; b: [[1, 3]] - auto indexScan1 = - makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 1 << "" << 1), BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << 1 << "" << 3)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[1, 1], [2, 2]]; d: [[1, 1], [3, 3]], e: [[1, 1]] - auto indexScan2 = - makeIndexScan(BSON("c" << 1 << "d" << 1 << "e" << 1), - { - makeOIL("c", {BSON("" << 1 << "" << 1), BSON("" << 2 << "" << 2)}), - makeOIL("d", {BSON("" << 1 << "" << 1), BSON("" << 3 << "" << 3)}), - makeOIL("e", {BSON("" << 1 << "" << 1)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_ClosedIntervalPrefixWins) { - // a: [[1, 1], [2, 2]]; b: [[1, MaxKey]] - auto indexScan1 = - makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 1 << "" << 1), BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << 1 << "" << MAXKEY)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[1, 1], [2, 2]]; d: [[1, 3]] - auto indexScan2 = - makeIndexScan(BSON("c" << 1 << "d" << 1 << "e" << 1), - { - makeOIL("c", {BSON("" << 1 << "" << 1), BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << 1 << "" << 3)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_LongerPrefixWins) { - // a: [[2, 3]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[5, 10]]; d: [[10, 20]], e: [[1, 101]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1 << "e" << 1), - { - makeOIL("c", {BSON("" << 5 << "" << 10)}), - makeOIL("d", {BSON("" << 10 << "" << 20)}), - makeOIL("e", {BSON("" << 1 << "" << 101)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_MultipleWinners) { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[5, 5]]; d: [[10, 20]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 5 << "" << 5)}), - makeOIL("d", {BSON("" << 10 << "" << 10)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(2, winners.size()); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_ShortestIndexKeyWins) { - // a: [[2, 2]]; b: [[MinKey, MaxKey]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << MINKEY << "" << MAXKEY)}), - }); - auto solution1 = makeSolution(std::move(indexScan1)); - - // c: [[5, 5]] - auto indexScan2 = makeIndexScan(BSON("c" << 1), - { - makeOIL("c", {BSON("" << 5 << "" << 5)}), - }); - auto solution2 = makeSolution(std::move(indexScan2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, SingleIndexScan_DifferentQueryShapesNoWin) { - // FETCH <- INDEX_SCAN - auto indexScan = - makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 1 << "" << 1), BSON("" << 2 << "" << 2)}), - makeOIL("b", {BSON("" << 1 << "" << 3)}), - }); - auto solution1 = makeSolution(std::move(indexScan)); - - // FETCH <- COLLECTION_SCAN - auto collScan = std::make_unique<CollectionScanNode>(); - auto solution2 = makeSolution(std::move(collScan)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(0, winners.size()); -} - - -TEST(IndexPrefixHeuristicTest, UnionIndexScan_ShortestIndexKeyWins) { - auto orNode1 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]], d: [[MaxKey, MinKey]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - makeOIL("d", {BSON("" << MAXKEY << "" << MINKEY)}), - }); - orNode1->children.emplace_back(indexScan1.release()); - orNode1->children.emplace_back(indexScan2.release()); - } - auto solution1 = makeSolution(std::move(orNode1)); - - auto orNode2 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]] - auto indexScan2 = makeIndexScan(BSON("c" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - }); - orNode2->children.emplace_back(indexScan1.release()); - orNode2->children.emplace_back(indexScan2.release()); - } - auto solution2 = makeSolution(std::move(orNode2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(1, winners.size()); - ASSERT_EQ(1, winners[0]); -} - -TEST(IndexPrefixHeuristicTest, UnionIndexScan_MultipleWinners) { - auto orNode1 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]] - auto indexScan2 = makeIndexScan(BSON("c" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - }); - orNode1->children.emplace_back(indexScan1.release()); - orNode1->children.emplace_back(indexScan2.release()); - } - auto solution1 = makeSolution(std::move(orNode1)); - - auto orNode2 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]], d: [[MaxKey, MinKey]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - makeOIL("d", {BSON("" << MAXKEY << "" << MINKEY)}), - }); - orNode2->children.emplace_back(indexScan1.release()); - orNode2->children.emplace_back(indexScan2.release()); - } - auto solution2 = makeSolution(std::move(orNode2)); - - auto orNode3 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]] - auto indexScan2 = makeIndexScan(BSON("c" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - }); - orNode3->children.emplace_back(indexScan1.release()); - orNode3->children.emplace_back(indexScan2.release()); - } - auto solution3 = makeSolution(std::move(orNode3)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get(), solution3.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(2, winners.size()); - ASSERT_EQ(0, winners[0]); - ASSERT_EQ(2, winners[1]); -} - -TEST(IndexPrefixHeuristicTest, UnionIndexScan_DifferentQueryShapeNoWin) { - auto orNode1 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]], d: [[MaxKey, MinKey]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - makeOIL("d", {BSON("" << MAXKEY << "" << MINKEY)}), - }); - orNode1->children.emplace_back(indexScan1.release()); - orNode1->children.emplace_back(indexScan2.release()); - } - auto solution1 = makeSolution(std::move(orNode1)); - - auto orNode2 = std::make_unique<OrNode>(); - { - // a: [[2, 2]]; b: [[1, 1]] - auto indexScan1 = makeIndexScan(BSON("a" << 1 << "b" << 1), - { - makeOIL("a", {BSON("" << 2 << "" << 3)}), - makeOIL("b", {BSON("" << 1 << "" << 1)}), - }); - - // c: [[2, 2]], d: [[MaxKey, MinKey]] - auto indexScan2 = makeIndexScan(BSON("c" << 1 << "d" << 1), - { - makeOIL("c", {BSON("" << 2 << "" << 2)}), - makeOIL("d", {BSON("" << MAXKEY << "" << MINKEY)}), - }); - - // e: [[2, 2]] - auto indexScan3 = makeIndexScan(BSON("e" << 1), - { - makeOIL("e", {BSON("" << 2 << "" << 2)}), - }); - orNode2->children.emplace_back(indexScan1.release()); - orNode2->children.emplace_back(indexScan2.release()); - orNode2->children.emplace_back(indexScan3.release()); - } - auto solution2 = makeSolution(std::move(orNode2)); - - std::vector<const QuerySolution*> solutions{solution1.get(), solution2.get()}; - auto winners = applyIndexPrefixHeuristic(solutions); - ASSERT_EQ(0, winners.size()); -} -} // namespace mongo::plan_ranker diff --git a/src/mongo/db/query/plan_ranker_util.h b/src/mongo/db/query/plan_ranker_util.h index 60a86205699..4874969db0d 100644 --- a/src/mongo/db/query/plan_ranker_util.h +++ b/src/mongo/db/query/plan_ranker_util.h @@ -29,8 +29,6 @@ #pragma once -#include <algorithm> - #include "mongo/db/query/plan_explainer_factory.h" #include "mongo/db/query/plan_ranker.h" @@ -47,130 +45,6 @@ namespace mongo::plan_ranker { std::unique_ptr<PlanScorer<PlanStageStats>> makePlanScorer(); /** - * Takes a vector of pairs holding (score, planIndex). - * Returns an iterator pointing to the first non-tying plan, or the end of the vector. - */ -inline std::vector<std::pair<double, size_t>>::iterator findTopTiedPlans( - std::vector<std::pair<double, size_t>>& plans) { - return std::find_if(plans.begin(), plans.end(), [&plans](const auto& plan) { - return plan.first != plans[0].first; - }); -} - -/** - * Holds information about tie breaking heuristic bonuses. It is used to update candidate plan score - * and log the bonuses. - */ -struct TieBreakingScores { - TieBreakingScores(bool isPlanTied, double score) - : isPlanTied(isPlanTied), score(score), docsExaminedBonus(0.0), indexPrefixBonus(0.0) {} - - double getTotalBonus() const { - return docsExaminedBonus + indexPrefixBonus; - } - - const bool isPlanTied; - const double score; - double docsExaminedBonus; - double indexPrefixBonus; -}; - -/** - * Apply docs examined tie breaking heuristic and return bonuses in 'scores' list. 'candidates' and - * 'scores' are synchronized, with the i-th score from 'scores' corresponding to the i-th - * 'candidate.' - */ -template <typename PlanStageType, typename ResultType, typename Data> -void calcDocsExaminedHeuristicBonus( - const std::vector<std::pair<double, size_t>>& scoresAndCandidateIndices, - size_t numberOfTiedPlans, - const std::vector<BaseCandidatePlan<PlanStageType, ResultType, Data>>& candidates, - const std::vector<size_t>& documentsExamined, - std::vector<TieBreakingScores>& scores) { - // The vector tiedPlans holds the number of documents and the plan's index. - std::vector<std::pair<double, size_t>> tiedPlans{}; - tiedPlans.reserve(numberOfTiedPlans); - for (size_t i = 0; i < numberOfTiedPlans; ++i) { - const size_t candidateIndex = scoresAndCandidateIndices[i].second; - tiedPlans.emplace_back(std::make_pair(documentsExamined[candidateIndex], candidateIndex)); - } - - // Sort top plans by least documents examined, and allocate a bonus to each of the top plans. - std::stable_sort(tiedPlans.begin(), tiedPlans.end(), [](const auto& lhs, const auto& rhs) { - return lhs.first < rhs.first; - }); - auto stillTiedPlansEnd = findTopTiedPlans(tiedPlans); - for (auto topPlan = tiedPlans.begin(); topPlan < stillTiedPlansEnd; ++topPlan) { - scores[topPlan->second].docsExaminedBonus = kBonusEpsilon; - } -} - -/** - * Apply best index prefix tie breaking heuristic and return bonuses in 'scores' list. 'candidates' - * and 'scores' are synchronized, with the i-th score from 'scores' corresponding to the i-th - * 'candidate.' - */ -template <typename PlanStageType, typename ResultType, typename Data> -void calcIndexPrefixHeuristicBonus( - const std::vector<std::pair<double, size_t>>& scoresAndCandidateIndices, - size_t numberOfTiedPlans, - const std::vector<BaseCandidatePlan<PlanStageType, ResultType, Data>>& candidates, - std::vector<TieBreakingScores>& scores) { - std::vector<const QuerySolution*> solutions{}; - solutions.reserve(numberOfTiedPlans); - - for (size_t i = 0; i < numberOfTiedPlans; ++i) { - const size_t candidateIndex = scoresAndCandidateIndices[i].second; - solutions.emplace_back(candidates[candidateIndex].solution.get()); - } - - auto winIndices = applyIndexPrefixHeuristic(solutions); - for (auto winIndex : winIndices) { - const auto candidateIndex = scoresAndCandidateIndices[winIndex].second; - scores[candidateIndex].indexPrefixBonus += 2 * kBonusEpsilon; - } -} - -/** - * Apply tie-breaking hearistics and update candidate plan scores. - */ -template <typename PlanStageType, typename ResultType, typename Data> -void addTieBreakingHeuristicsBonuses( - std::vector<std::pair<double, size_t>>& scoresAndCandidateIndices, - const std::vector<BaseCandidatePlan<PlanStageType, ResultType, Data>>& candidates, - const std::vector<size_t>& documentsExamined) { - auto tiedPlansEnd = findTopTiedPlans(scoresAndCandidateIndices); - int numberOfTiedPlans = std::distance(scoresAndCandidateIndices.begin(), tiedPlansEnd); - - if (numberOfTiedPlans > 1) { - // Initialize 'scores' list. 'candidates' and 'scores' are synchronized, with the i-th score - // from 'scores' corresponding to the i-th 'candidate.' - std::vector<TieBreakingScores> scores{}; - scores.reserve(candidates.size()); - for (size_t i = 0; i < scoresAndCandidateIndices.size(); ++i) { - scores.emplace_back(/* isPlanTied */ i < static_cast<size_t>(numberOfTiedPlans), - /* score */ scoresAndCandidateIndices[i].first); - } - - calcDocsExaminedHeuristicBonus( - scoresAndCandidateIndices, numberOfTiedPlans, candidates, documentsExamined, scores); - - calcIndexPrefixHeuristicBonus( - scoresAndCandidateIndices, numberOfTiedPlans, candidates, scores); - - // Log tie breaking bonuses. - for (const auto& score : scores) { - log_detail::logTieBreaking( - score.score, score.docsExaminedBonus, score.indexPrefixBonus, score.isPlanTied); - } - - for (auto& scoreAndIndex : scoresAndCandidateIndices) { - scoreAndIndex.first += scores[scoreAndIndex.second].getTotalBonus(); - } - } -} - -/** * Returns a PlanRankingDecision which has the ranking and the information about the ranking * process with status OK if everything worked. 'candidateOrder' within the PlanRankingDecision * holds indices into candidates ordered by score (winner in first element). @@ -201,7 +75,6 @@ StatusWith<std::unique_ptr<PlanRankingDecision>> pickBestPlan( // Used to derive scores and candidate ordering. std::vector<std::pair<double, size_t>> scoresAndCandidateIndices; std::vector<size_t> failed; - std::vector<size_t> documentsExamined; // Compute score for each tree. Record the best. for (size_t i = 0; i < statTrees.size(); ++i) { @@ -244,11 +117,6 @@ StatusWith<std::unique_ptr<PlanRankingDecision>> pickBestPlan( candidates[i].solution->score = score; scoresAndCandidateIndices.push_back(std::make_pair(score, i)); - - // Collect some information about documents examined for tie breaking later. - PlanSummaryStats stats; - explainer->getSummaryStats(&stats); - documentsExamined.push_back(stats.totalDocsExamined); } else { failed.push_back(i); log_detail::logFailedPlan([&] { return explainer->getPlanSummary(); }); @@ -270,16 +138,6 @@ StatusWith<std::unique_ptr<PlanRankingDecision>> pickBestPlan( return lhs.first > rhs.first; }); - // Apply tie-breaking heuristics. - if (internalQueryPlanTieBreakingWithIndexHeuristics.load()) { - addTieBreakingHeuristicsBonuses(scoresAndCandidateIndices, candidates, documentsExamined); - - // Re-sort the candidates. - std::stable_sort(scoresAndCandidateIndices.begin(), - scoresAndCandidateIndices.end(), - [](const auto& lhs, const auto& rhs) { return lhs.first > rhs.first; }); - } - auto why = std::make_unique<PlanRankingDecision>(); if constexpr (std::is_same_v<PlanStageStatsType, mongo::sbe::PlanStageStats>) { diff --git a/src/mongo/db/query/plan_summary_stats.h b/src/mongo/db/query/plan_summary_stats.h index 5c153ef3e39..ac80b6505f3 100644 --- a/src/mongo/db/query/plan_summary_stats.h +++ b/src/mongo/db/query/plan_summary_stats.h @@ -29,7 +29,6 @@ #pragma once -#include "mongo/util/duration.h" #include <optional> #include <string> diff --git a/src/mongo/db/query/plan_yield_policy.cpp b/src/mongo/db/query/plan_yield_policy.cpp index 79816505026..58064f76d6e 100644 --- a/src/mongo/db/query/plan_yield_policy.cpp +++ b/src/mongo/db/query/plan_yield_policy.cpp @@ -32,7 +32,6 @@ #include "mongo/db/query/plan_yield_policy.h" #include "mongo/db/catalog/collection.h" -#include "mongo/db/concurrency/exception_util.h" #include "mongo/db/concurrency/write_conflict_exception.h" #include "mongo/db/operation_context.h" #include "mongo/util/scopeguard.h" @@ -40,43 +39,17 @@ namespace mongo { -PlanYieldPolicy::PlanYieldPolicy(OperationContext* opCtx, - YieldPolicy policy, +PlanYieldPolicy::PlanYieldPolicy(YieldPolicy policy, ClockSource* cs, int yieldIterations, Milliseconds yieldPeriod, const Yieldable* yieldable, std::unique_ptr<const YieldPolicyCallbacks> callbacks) - : _policy(getPolicyOverrideForOperation(opCtx, policy)), + : _policy(policy), _yieldable(yieldable), _callbacks(std::move(callbacks)), _elapsedTracker(cs, yieldIterations, yieldPeriod) {} -PlanYieldPolicy::YieldPolicy PlanYieldPolicy::getPolicyOverrideForOperation( - OperationContext* opCtx, PlanYieldPolicy::YieldPolicy desired) { - // We may have a null opCtx in testing. - if (MONGO_unlikely(!opCtx)) { - return desired; - } - // Multi-document transactions cannot yield locks or snapshots. We convert to a non-yielding - // interruptible plan. - if (opCtx->inMultiDocumentTransaction() && - (desired == YieldPolicy::YIELD_AUTO || desired == YieldPolicy::YIELD_MANUAL || - desired == YieldPolicy::WRITE_CONFLICT_RETRY_ONLY)) { - return YieldPolicy::INTERRUPT_ONLY; - } - - // If the state of our locks held is not yieldable at all, we will assume this is an internal - // operation that should not be interrupted or yielded. - // TODO: SERVER-76238 Evaluate if we can make everything INTERRUPT_ONLY instead. - if (!opCtx->lockState()->canSaveLockState() && - (desired == YieldPolicy::YIELD_AUTO || desired == YieldPolicy::YIELD_MANUAL)) { - return YieldPolicy::NO_YIELD; - } - - return desired; -} - bool PlanYieldPolicy::shouldYieldOrInterrupt(OperationContext* opCtx) { if (_policy == YieldPolicy::INTERRUPT_ONLY) { return _elapsedTracker.intervalHasElapsed(); @@ -157,7 +130,7 @@ Status PlanYieldPolicy::yieldOrInterrupt(OperationContext* opCtx, if (_callbacks) { _callbacks->handledWriteConflict(opCtx); } - logWriteConflictAndBackoff(attempt, "query yield", ""_sd); + WriteConflictException::logAndBackoff(attempt, "query yield", ""_sd); // Retry the yielding process. } catch (...) { // Errors other than write conflicts don't get retried, and should instead result in @@ -174,34 +147,46 @@ void PlanYieldPolicy::performYield(OperationContext* opCtx, std::function<void()> whileYieldingFn) { // Things have to happen here in a specific order: // * Release 'yieldable'. - // * Abandon the current storage engine snapshot. + // * Release lock mgr locks. // * Check for interrupt if the yield policy requires. - // * Release lock manager locks. - // * Reacquire lock manager locks. + // * Abondon the query's current storage engine snapshot. + // * Reacquire lock mgr locks. // * Restore 'yieldable'. - invariant(_policy == YieldPolicy::YIELD_AUTO || _policy == YieldPolicy::YIELD_MANUAL); + Locker* locker = opCtx->lockState(); + + if (locker->isGlobalLockedRecursively()) { + // No purpose in yielding if the locks are recursively held and cannot be released. + return; + } - // If we are here, the caller has guaranteed locks are not recursively held. This is a top level - // operation and we can safely clear the 'yieldable' state before unlocking and then - // re-establish it after re-locking. + // Since the locks are not recursively held, this is a top level operation and we can safely + // clear the 'yieldable' state before unlocking and then re-establish it after re-locking. if (yieldable) { yieldable->yield(); } - // Release any storage engine resources. This requires holding a global lock to correctly - // synchronize with states such as shutdown and rollback. - opCtx->recoveryUnit()->abandonSnapshot(); + Locker::LockSnapshot snapshot; + auto unlocked = locker->saveLockStateAndUnlock(&snapshot); - // Check for interrupt before releasing locks. This avoids the complexities of having to - // re-acquire locks to clean up when we are interrupted. This is the main interrupt check during - // query execution. Yield points and interrupt points are one and the same. + // After all steps to relinquish locks and save the execution plan have been taken, check + // for interrupt. This is the main interrupt check during query execution. Yield points and + // interrupt points are one and the same. if (getPolicy() == PlanYieldPolicy::YieldPolicy::YIELD_AUTO) { opCtx->checkForInterrupt(); // throws } - Locker* locker = opCtx->lockState(); - Locker::LockSnapshot snapshot; - locker->saveLockStateAndUnlock(&snapshot); + if (!unlocked) { + // Nothing was unlocked. Recursively held locks are not the only reason locks cannot be + // released. Restore the 'yieldable' state before returning. + if (yieldable) { + yieldable->restore(); + } + return; + } + + // Top-level locks are freed, release any potential low-level (storage engine-specific + // locks). If we are yielding, we are at a safe place to do so. + opCtx->recoveryUnit()->abandonSnapshot(); if (_callbacks) { _callbacks->duringYield(opCtx); diff --git a/src/mongo/db/query/plan_yield_policy.h b/src/mongo/db/query/plan_yield_policy.h index 05bbc5b40eb..9d44ba8e903 100644 --- a/src/mongo/db/query/plan_yield_policy.h +++ b/src/mongo/db/query/plan_yield_policy.h @@ -172,24 +172,14 @@ public: } /** - * Returns the policy that this operation should use, accounting for any special circumstances, - * and otherwise the desired policy. Should always be used when constructing a PlanYieldPolicy. - */ - static YieldPolicy getPolicyOverrideForOperation(OperationContext* opCtx, YieldPolicy desired); - - /** * Constructs a PlanYieldPolicy of the given 'policy' type. This class uses an ElapsedTracker * to keep track of elapsed time, which is initialized from the parameters 'cs', * 'yieldIterations' and 'yieldPeriod'. * * If provided, the given 'yieldable' is released and restored by the 'PlanYieldPolicy' (in - * addition to releasing/restoring locks and the storage engine snapshot). The provided 'policy' - * will be overridden depending on the nature of this operation. For example, multi-document - * transactions will always downgrade to INTERRUPT_ONLY, and operations with recursively held - * locks will downgrade to NO_YIELD. + * addition to releasing/restoring locks and the storage engine snapshot). */ - PlanYieldPolicy(OperationContext* opCtx, - YieldPolicy policy, + PlanYieldPolicy(YieldPolicy policy, ClockSource* cs, int yieldIterations, Milliseconds yieldPeriod, diff --git a/src/mongo/db/query/plan_yield_policy_impl.cpp b/src/mongo/db/query/plan_yield_policy_impl.cpp index 8b45e2998ed..e4f0688c97f 100644 --- a/src/mongo/db/query/plan_yield_policy_impl.cpp +++ b/src/mongo/db/query/plan_yield_policy_impl.cpp @@ -39,8 +39,9 @@ PlanYieldPolicyImpl::PlanYieldPolicyImpl(PlanExecutorImpl* exec, PlanYieldPolicy::YieldPolicy policy, const Yieldable* yieldable, std::unique_ptr<YieldPolicyCallbacks> callbacks) - : PlanYieldPolicy(exec->getOpCtx(), - policy, + : PlanYieldPolicy(exec->getOpCtx()->lockState()->isGlobalLockedRecursively() + ? PlanYieldPolicy::YieldPolicy::NO_YIELD + : policy, exec->getOpCtx()->getServiceContext()->getFastClockSource(), internalQueryExecYieldIterations.load(), Milliseconds{internalQueryExecYieldPeriodMS.load()}, diff --git a/src/mongo/db/query/plan_yield_policy_sbe.h b/src/mongo/db/query/plan_yield_policy_sbe.h index 2286dcb6434..d0c0ea81fa7 100644 --- a/src/mongo/db/query/plan_yield_policy_sbe.h +++ b/src/mongo/db/query/plan_yield_policy_sbe.h @@ -36,21 +36,15 @@ namespace mongo { class PlanYieldPolicySBE final : public PlanYieldPolicy { public: - PlanYieldPolicySBE(OperationContext* opCtx, - YieldPolicy policy, + PlanYieldPolicySBE(YieldPolicy policy, ClockSource* clockSource, int yieldFrequency, Milliseconds yieldPeriod, const Yieldable* yieldable, std::unique_ptr<YieldPolicyCallbacks> callbacks, bool useExperimentalCommitTxnBehavior) - : PlanYieldPolicy(opCtx, - policy, - clockSource, - yieldFrequency, - yieldPeriod, - yieldable, - std::move(callbacks)), + : PlanYieldPolicy( + policy, clockSource, yieldFrequency, yieldPeriod, yieldable, std::move(callbacks)), _useExperimentalCommitTxnBehavior(useExperimentalCommitTxnBehavior) { uassert(4822879, "WRITE_CONFLICT_RETRY_ONLY yield policy is not supported in SBE", diff --git a/src/mongo/db/query/planner_access.cpp b/src/mongo/db/query/planner_access.cpp index de294ad661a..e05dfd8a5d1 100644 --- a/src/mongo/db/query/planner_access.cpp +++ b/src/mongo/db/query/planner_access.cpp @@ -45,21 +45,14 @@ #include "mongo/db/matcher/expression.h" #include "mongo/db/matcher/expression_array.h" #include "mongo/db/matcher/expression_geo.h" -#include "mongo/db/matcher/expression_internal_expr_comparison.h" -#include "mongo/db/matcher/expression_leaf.h" #include "mongo/db/matcher/expression_text.h" -#include "mongo/db/matcher/expression_tree.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/query/index_bounds.h" #include "mongo/db/query/index_bounds_builder.h" #include "mongo/db/query/index_tag.h" #include "mongo/db/query/indexability.h" -#include "mongo/db/query/parsed_find_command.h" #include "mongo/db/query/planner_wildcard_helpers.h" #include "mongo/db/query/query_knobs_gen.h" #include "mongo/db/query/query_planner.h" #include "mongo/db/query/query_planner_common.h" -#include "mongo/db/query/record_id_range.h" #include "mongo/db/record_id_helpers.h" #include "mongo/logv2/log.h" #include "mongo/util/transitional_tools_do_not_use/vector_spooling.h" @@ -235,37 +228,27 @@ bool affectedByCollator(const BSONElement& element) { } } -// Set 'curr' to 'newMin' if 'newMin' < 'curr' -void setLowestRecord(boost::optional<RecordIdBound>& curr, const RecordIdBound& newMin) { - if (!curr || newMin.recordId() < curr->recordId()) { - curr = newMin; +void setMinRecord(CollectionScanNode* collScan, const BSONObj& min) { + const auto newMinRecord = record_id_helpers::keyForObj(min); + if (!collScan->minRecord || newMinRecord > collScan->minRecord->recordId()) { + collScan->minRecord = RecordIdBound(newMinRecord, min); } } -// Set 'curr' to 'newMax' if 'newMax' > 'curr' -void setHighestRecord(boost::optional<RecordIdBound>& curr, const RecordIdBound& newMax) { - if (!curr || newMax.recordId() > curr->recordId()) { - curr = newMax; +void setMaxRecord(CollectionScanNode* collScan, const BSONObj& max) { + const auto newMaxRecord = record_id_helpers::keyForObj(max); + if (!collScan->maxRecord || newMaxRecord < collScan->maxRecord->recordId()) { + collScan->maxRecord = RecordIdBound(newMaxRecord, max); } } -// Set 'curr' to 'newMin' if 'newMin' < 'curr' -void setLowestRecord(boost::optional<RecordIdBound>& curr, const BSONObj& newMin) { - setLowestRecord(curr, RecordIdBound(record_id_helpers::keyForObj(newMin), newMin)); -} - -// Set 'curr' to 'newMax' if 'newMax' > 'curr' -void setHighestRecord(boost::optional<RecordIdBound>& curr, const BSONObj& newMax) { - setHighestRecord(curr, RecordIdBound(record_id_helpers::keyForObj(newMax), newMax)); -} - // Returns whether element is not affected by collators or query and collection collators are // compatible. bool compatibleCollator(const QueryPlannerParams& params, const CollatorInterface* queryCollator, const BSONElement& element) { auto const collCollator = params.clusteredCollectionCollator; - bool compatible = CollatorInterface::collatorsMatch(queryCollator, collCollator); + bool compatible = !queryCollator || (collCollator && *queryCollator == *collCollator); return compatible || !affectedByCollator(element); } @@ -276,8 +259,7 @@ bool compatibleCollator(const QueryPlannerParams& params, void handleRIDRangeMinMax(const CanonicalQuery& query, CollectionScanNode* collScan, const QueryPlannerParams& params, - const CollatorInterface* collator, - RecordIdRange& recordRange) { + const CollatorInterface* collator) { BSONObj minObj = query.getFindCommandRequest().getMin(); BSONObj maxObj = query.getFindCommandRequest().getMax(); if (minObj.isEmpty() && maxObj.isEmpty()) { @@ -297,170 +279,88 @@ void handleRIDRangeMinMax(const CanonicalQuery& query, if (!maxObj.isEmpty() && compatibleCollator(params, collator, maxObj.firstElement())) { // max() is exclusive. // Assumes clustered collection scans are only supported with the forward direction. - recordRange.maybeNarrowMax( - IndexBoundsBuilder::objFromElement(maxObj.firstElement(), collator), - false /* NOT inclusive*/); + collScan->boundInclusion = + CollectionScanParams::ScanBoundInclusion::kIncludeStartRecordOnly; + setMaxRecord(collScan, IndexBoundsBuilder::objFromElement(maxObj.firstElement(), collator)); } if (!minObj.isEmpty() && compatibleCollator(params, collator, minObj.firstElement())) { // The min() is inclusive as are bounded collection scans by default. - recordRange.maybeNarrowMin( - IndexBoundsBuilder::objFromElement(minObj.firstElement(), collator), - true /* inclusive*/); + setMinRecord(collScan, IndexBoundsBuilder::objFromElement(minObj.firstElement(), collator)); } } /** * Helper function to add an RID range to collection scans. - * If the query solution tree contains a collection scan node with a suitable comparison predicate - * on '_id', we add a minRecord and maxRecord on the collection node. - * - * Returns true if the MatchExpression is a comparison against the cluster key which either: - * 1) is guaranteed to exclude values of the cluster key which are affected by collation or - * 2) may return values of the cluster key which are affected by collation, but the query and - * collection collations match. - * Otherwise, returns false. - * - * For example, assuming the cluster key is "_id": - * Given {a: {$eq: 2}}, we return false, because the comparison is not against the cluster key. - * Given {_id: {$gte: 5}}, we return true, because this comparison against the cluster key excludes - * keys which are affected by collations. - * Given {_id: {$eq: "str"}}, we return true only if the query and collection collations match. - * + * If the query solution tree contains a collection scan node with a suitable comparison + * predicate on '_id', we add a minRecord and maxRecord on the collection node. */ -[[nodiscard]] bool handleRIDRangeScan(const MatchExpression* conjunct, - CollectionScanNode* collScan, - const QueryPlannerParams& params, - const CollatorInterface* collator, - RecordIdRange& recordRange) { +void handleRIDRangeScan(const MatchExpression* conjunct, + CollectionScanNode* collScan, + const QueryPlannerParams& params, + const CollatorInterface* collator) { invariant(params.clusteredInfo); if (conjunct == nullptr) { - return false; + return; } auto* andMatchPtr = dynamic_cast<const AndMatchExpression*>(conjunct); if (andMatchPtr != nullptr) { - bool atLeastOneConjunctCompatibleCollation = false; for (size_t index = 0; index < andMatchPtr->numChildren(); index++) { - if (handleRIDRangeScan( - andMatchPtr->getChild(index), collScan, params, collator, recordRange)) { - atLeastOneConjunctCompatibleCollation = true; - } + handleRIDRangeScan(andMatchPtr->getChild(index), collScan, params, collator); } - - // If one of the conjuncts excludes values of the cluster key which are affected by - // collation, then the entire $and will also exclude those values. - return atLeastOneConjunctCompatibleCollation; + return; } if (conjunct->path() != clustered_util::getClusterKeyFieldName(params.clusteredInfo->getIndexSpec())) { // No match on the cluster key. - return false; - } - - // TODO SERVER-62707: Allow $in with regex to use a clustered index. - auto inMatch = dynamic_cast<const InMatchExpression*>(conjunct); - if (inMatch && !inMatch->hasRegex()) { - // Iterate through the $in equalities to find the min/max values. The min/max bounds for the - // collscan need to be loose enough to cover all of these values. - boost::optional<RecordIdBound> minBound; - boost::optional<RecordIdBound> maxBound; - - bool allEltsCollationCompatible = true; - for (const auto& element : inMatch->getEqualities()) { - if (compatibleCollator(params, collator, element)) { - const auto collated = IndexBoundsBuilder::objFromElement(element, collator); - setLowestRecord(minBound, collated); - setHighestRecord(maxBound, collated); - } else { - // Set coarse min/max bounds based on type when we can't set tight bounds. - allEltsCollationCompatible = false; - - BSONObjBuilder bMin; - bMin.appendMinForType("", element.type()); - setLowestRecord(minBound, bMin.obj()); - - BSONObjBuilder bMax; - bMax.appendMaxForType("", element.type()); - setHighestRecord(maxBound, bMax.obj()); - } - } - - // {min,max}RecordId will bound the range of ids scanned to the highest and lowest present - // in the InMatchExpression, but the filter is still required to filter to _exactly_ the - // requested matches. - - // Finally, tighten the collscan bounds with the min/max bounds for the $in. - recordRange.intersectRange(minBound, maxBound); - return allEltsCollationCompatible; + return; } - auto match = dynamic_cast<const ComparisonMatchExpressionBase*>(conjunct); + auto match = dynamic_cast<const ComparisonMatchExpression*>(conjunct); if (match == nullptr) { - return false; // Not a comparison match expression. + return; // Not a comparison match expression. } const auto& element = match->getData(); - if (!ComparisonMatchExpressionBase::isInternalExprComparison(match->matchType())) { - // Internal comparisons e.g., $_internalExprGt do _not_ carry type bracketing - // semantics (consistent with `$expr{$gt:[a,b]}`). - // For other comparisons which _do_ perform type bracketing, the RecordId bounds - // may be tightened here. - BSONObjBuilder minb; - minb.appendMinForType("", element.type()); - recordRange.maybeNarrowMin(minb.obj(), true /* inclusive */); + // Set coarse min/max bounds based on type in case we can't set tight bounds. + BSONObjBuilder minb; + minb.appendMinForType("", element.type()); + setMinRecord(collScan, minb.obj()); - BSONObjBuilder maxb; - maxb.appendMaxForType("", element.type()); - recordRange.maybeNarrowMax(maxb.obj(), true /* inclusive */); - } + BSONObjBuilder maxb; + maxb.appendMaxForType("", element.type()); + setMaxRecord(collScan, maxb.obj()); bool compatible = compatibleCollator(params, collator, element); if (!compatible) { - return false; // Collator affects probe and it's not compatible with collection's collator. + return; // Collator affects probe and it's not compatible with collection's collator. } // Even if the collations don't match at this point, it's fine, - // because the bounds exclude values that use it. - const BSONObj collated = IndexBoundsBuilder::objFromElement(element, collator); - using MType = MatchExpression::MatchType; - switch (match->matchType()) { - case MType::EQ: - case MType::INTERNAL_EXPR_EQ: - recordRange.maybeNarrowMin(collated, true /* inclusive */); - recordRange.maybeNarrowMax(collated, true /* inclusive */); - break; - case MType::LT: - case MType::INTERNAL_EXPR_LT: - recordRange.maybeNarrowMax(collated, false /* EXclusive */); - break; - case MType::LTE: - case MType::INTERNAL_EXPR_LTE: - recordRange.maybeNarrowMax(collated, true /* inclusive */); - break; - case MType::GT: - case MType::INTERNAL_EXPR_GT: - recordRange.maybeNarrowMin(collated, false /* EXclusive */); - break; - case MType::GTE: - case MType::INTERNAL_EXPR_GTE: - recordRange.maybeNarrowMin(collated, true /* inclusive */); - break; - default:; + // because the bounds exclude values that use it + collScan->hasCompatibleCollation = true; + + const auto collated = IndexBoundsBuilder::objFromElement(element, collator); + if (dynamic_cast<const EqualityMatchExpression*>(match)) { + setMinRecord(collScan, collated); + setMaxRecord(collScan, collated); + } else if (dynamic_cast<const LTMatchExpression*>(match) || + dynamic_cast<const LTEMatchExpression*>(match)) { + setMaxRecord(collScan, collated); + } else if (dynamic_cast<const GTMatchExpression*>(match) || + dynamic_cast<const GTEMatchExpression*>(match)) { + setMinRecord(collScan, collated); } - return true; } } // namespace std::unique_ptr<QuerySolutionNode> QueryPlannerAccess::makeCollectionScan( const CanonicalQuery& query, bool tailable, const QueryPlannerParams& params, int direction) { - // The following are expensive to look up, so only do it once for each. - const mongo::NamespaceString nss = query.nss(); - const bool isOplog = nss.isOplog(); // Make the (only) node, a collection scan. auto csn = std::make_unique<CollectionScanNode>(); csn->name = query.ns(); @@ -471,7 +371,6 @@ std::unique_ptr<QuerySolutionNode> QueryPlannerAccess::makeCollectionScan( csn->shouldWaitForOplogVisibility = params.options & QueryPlannerParams::OPLOG_SCAN_WAIT_FOR_VISIBLE; csn->direction = direction; - csn->isOplog = isOplog; if (params.clusteredInfo) { csn->clusteredIndex = params.clusteredInfo->getIndexSpec(); @@ -548,29 +447,14 @@ std::unique_ptr<QuerySolutionNode> QueryPlannerAccess::makeCollectionScan( auto queryCollator = query.getCollator(); auto collCollator = params.clusteredCollectionCollator; - csn->hasCompatibleCollation = CollatorInterface::collatorsMatch(queryCollator, collCollator); + csn->hasCompatibleCollation = + !queryCollator || (collCollator && *queryCollator == *collCollator); if (params.clusteredInfo && !csn->resumeAfterRecordId) { // This is a clustered collection. Attempt to perform an efficient, bounded collection scan - // via minRecord and maxRecord if applicable. During this process, we will check if the - // query is guaranteed to exclude values of the cluster key which are affected by collation. - // If so, then even if the query and collection collations differ, the collation difference - // won't affect the query results. In that case, we can say hasCompatibleCollation is true. - - RecordIdRange recordRange; - // min/max records may have been set if oplog or change collection. - recordRange.intersectRange(csn->minRecord, csn->maxRecord); - bool compatibleCollation = - handleRIDRangeScan(csn->filter.get(), csn.get(), params, queryCollator, recordRange); - csn->hasCompatibleCollation |= compatibleCollation; - - handleRIDRangeMinMax(query, csn.get(), params, queryCollator, recordRange); - - csn->minRecord = recordRange.getMin(); - csn->maxRecord = recordRange.getMax(); - - csn->boundInclusion = CollectionScanParams::makeInclusion(recordRange.isMinInclusive(), - recordRange.isMaxInclusive()); + // via minRecord and maxRecord if applicable. + handleRIDRangeScan(csn->filter.get(), csn.get(), params, queryCollator); + handleRIDRangeMinMax(query, csn.get(), params, queryCollator); } return csn; @@ -1230,13 +1114,47 @@ std::vector<std::unique_ptr<QuerySolutionNode>> QueryPlannerAccess::collapseEqui } /** - * This helper determines if a query can be covered depending on the query projection. + * Returns true if this is a null query that can retrieve all the information it needs directly from + * the index, and so does not need a FETCH stage on top of it. Returns false otherwise. */ -bool projNeedsFetch(const CanonicalQuery& query, const QueryPlannerParams& params) { +bool isCoveredNullQuery(const CanonicalQuery& query, + MatchExpression* root, + IndexTag* tag, + const vector<IndexEntry>& indices, + const QueryPlannerParams& params) { + // Sparse indexes and hashed indexes should not use this optimization as they will require a + // FETCH stage with a filter. + if (indices[tag->index].sparse || indices[tag->index].type == IndexType::INDEX_HASHED) { + return false; + } + + // When the index is not multikey, we can support a query on an indexed field searching for null + // values. This optimization can only be done when the index is not multikey, otherwise empty + // arrays in the collection will be treated as null/undefined by the index. When the index is + // multikey, we can support a query searching for both null and empty array values. + const auto multikeyIndex = indices[tag->index].multikey; + if (root->matchType() == MatchExpression::MatchType::MATCH_IN) { + // Check that the query matches null values, if the index is not multikey, or null and empty + // array values, if the index is multikey. Note that the query may match values other than + // null (and empty array). + const auto node = static_cast<const InMatchExpression*>(root); + if (!node->hasNull() || (multikeyIndex && !node->hasEmptyArray())) { + return false; + } + } else if (ComparisonMatchExpressionBase::isEquality(root->matchType()) && !multikeyIndex) { + // Check that the query matches null values. + const auto node = static_cast<const ComparisonMatchExpressionBase*>(root); + if (node->getData().type() != BSONType::jstNULL) { + return false; + } + } else { + return false; + } + // If nothing is being projected, the query is fully covered without a fetch. // This is trivially true for a count query. if (params.options & QueryPlannerParams::Options::IS_COUNT) { - return false; + return true; } // This optimization can only be used for find when the index covers the projection completely. @@ -1245,7 +1163,7 @@ bool projNeedsFetch(const CanonicalQuery& query, const QueryPlannerParams& param // in the multikey case). Hence, only find queries projecting _id are covered. auto proj = query.getProj(); if (!proj) { - return true; + return false; } // We can cover projections on _id and generated fields and expressions depending only on _id. @@ -1257,38 +1175,10 @@ bool projNeedsFetch(const CanonicalQuery& query, const QueryPlannerParams& param // Note that it is not possible to project onto dotted paths of _id here, since they may be // null or missing, and the index cannot differentiate between the two cases, so we would // still need a FETCH stage. - if (projFields.size() == 1 && *projFields.begin() == "_id") { - return false; - } + return projFields.size() == 1 && *projFields.begin() == "_id"; } - return true; -} - -/** - * This helper updates a MAYBE_COVERED query tightness to one of EXACT, INEXACT_COVERED, or - * INEXACT_FETCH, depending on whether we need a FETCH/filter to answer the query projection. - */ -void refineTightnessForMaybeCoveredQuery(const CanonicalQuery& query, - const QueryPlannerParams& params, - IndexBoundsBuilder::BoundsTightness& tightnessOut) { - // We need to refine the tightness in case we have a "MAYBE_COVERED" tightness bound which - // depends on the query's projection. We will not have information about the projection - // later on in order to make this determination, so we do it here. - const bool noFetchNeededForProj = !projNeedsFetch(query, params); - if (tightnessOut == IndexBoundsBuilder::EXACT_MAYBE_COVERED) { - if (noFetchNeededForProj) { - tightnessOut = IndexBoundsBuilder::EXACT; - } else { - tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; - } - } else if (tightnessOut == IndexBoundsBuilder::INEXACT_MAYBE_COVERED) { - if (noFetchNeededForProj) { - tightnessOut = IndexBoundsBuilder::INEXACT_COVERED; - } else { - tightnessOut = IndexBoundsBuilder::INEXACT_FETCH; - } - } + return false; } bool QueryPlannerAccess::processIndexScans(const CanonicalQuery& query, @@ -1332,6 +1222,11 @@ bool QueryPlannerAccess::processIndexScans(const CanonicalQuery& query, // If we're here, we now know that 'child' can use an index directly and the index is // over the child's field. + // We need to track if this is a covered null query so that we can have this information + // at hand when handling the filter on an indexed AND. + scanState.isCoveredNullQuery = + isCoveredNullQuery(query, child, scanState.ixtag, indices, params); + // If 'child' is a NOT, then the tag we're interested in is on the NOT's // child node. if (MatchExpression::NOT == child->matchType()) { @@ -1364,7 +1259,6 @@ bool QueryPlannerAccess::processIndexScans(const CanonicalQuery& query, verify(scanState.currentIndexNumber == scanState.ixtag->index); scanState.tightness = IndexBoundsBuilder::INEXACT_FETCH; mergeWithLeafNode(child, &scanState); - refineTightnessForMaybeCoveredQuery(query, params, scanState.tightness); handleFilter(&scanState); } else { if (nullptr != scanState.currentScan.get()) { @@ -1384,7 +1278,6 @@ bool QueryPlannerAccess::processIndexScans(const CanonicalQuery& query, &scanState.tightness, scanState.getCurrentIETBuilder()); - refineTightnessForMaybeCoveredQuery(query, params, scanState.tightness); handleFilter(&scanState); } } @@ -1800,12 +1693,6 @@ std::unique_ptr<QuerySolutionNode> QueryPlannerAccess::_buildIndexedDataAccess( return soln; } - // We may be able to avoid adding an extra fetch stage even though the bounds are - // inexact, for instance if the query is counting null values on an indexed field - // without projecting that field. We therefore convert "MAYBE_COVERED" bounds into - // either EXACT or INEXACT, depending on the query projection. - refineTightnessForMaybeCoveredQuery(query, params, tightness); - // If the bounds are exact, the set of documents that satisfy the predicate is // exactly equal to the set of documents that the scan provides. // @@ -1813,7 +1700,11 @@ std::unique_ptr<QuerySolutionNode> QueryPlannerAccess::_buildIndexedDataAccess( // superset of documents that satisfy the predicate, and we must check the // predicate. - if (tightness == IndexBoundsBuilder::EXACT) { + // We may also be able to avoid adding an extra fetch stage even though the bounds are + // inexact because the query is counting null values on an indexed field without + // projecting that field. + if (tightness == IndexBoundsBuilder::EXACT || + isCoveredNullQuery(query, root, tag, indices, params)) { return soln; } else if (tightness == IndexBoundsBuilder::INEXACT_COVERED && !indices[tag->index].multikey) { @@ -1959,9 +1850,10 @@ void QueryPlannerAccess::handleFilterAnd(ScanBuildingState* scanState) { // should always be affixed as a filter. We keep 'curChild' in the $and // for affixing later. ++scanState->curChild; - } else if (scanState->tightness == IndexBoundsBuilder::EXACT) { - // The tightness of the bounds is exact. We want to remove this child so that when control - // returns to handleIndexedAnd we know that we don't need it to create a FETCH stage. + } else if (scanState->tightness == IndexBoundsBuilder::EXACT || scanState->isCoveredNullQuery) { + // The tightness of the bounds is exact or we are dealing with a covered null query. + // Either way, we want to remove this child so that when control returns to handleIndexedAnd + // we know that we don't need it to create a FETCH stage. root->getChildVector()->erase(root->getChildVector()->begin() + scanState->curChild); } else if (scanState->tightness == IndexBoundsBuilder::INEXACT_COVERED && (INDEX_TEXT == index.type || !index.multikey)) { diff --git a/src/mongo/db/query/planner_access.h b/src/mongo/db/query/planner_access.h index a5bfc04bb51..6ea44830415 100644 --- a/src/mongo/db/query/planner_access.h +++ b/src/mongo/db/query/planner_access.h @@ -106,7 +106,7 @@ public: static std::unique_ptr<QuerySolutionNode> makeCollectionScan(const CanonicalQuery& query, bool tailable, const QueryPlannerParams& params, - int direction); + int direction = 1); /** * Return a plan that uses the provided index as a proxy for a collection scan. @@ -126,7 +126,7 @@ public: const BSONObj& endKey); /** - * Constructs a data access plan for 'query' which answers the predicate contained in 'root'. + * Consructs a data access plan for 'query' which answers the predicate contained in 'root'. * Assumes the presence of the passed in indices. Planning behavior is controlled by the * settings in 'params'. */ @@ -145,9 +145,11 @@ private: struct ScanBuildingState { ScanBuildingState(MatchExpression* theRoot, const std::vector<IndexEntry>& indexList, - bool inArrayOp) + bool inArrayOp, + bool isCoveredNull = false) : root(theRoot), inArrayOperator(inArrayOp), + isCoveredNullQuery(isCoveredNull), indices(indexList), currentScan(nullptr), curChild(0), @@ -186,6 +188,9 @@ private: // Are we inside an array operator such as $elemMatch or $all? bool inArrayOperator; + // Is this a covered null query? + bool isCoveredNullQuery; + // A list of relevant indices which 'root' may be tagged to use. const std::vector<IndexEntry>& indices; diff --git a/src/mongo/db/query/planner_access_test.cpp b/src/mongo/db/query/planner_access_test.cpp index d30544b43fa..52df32c871e 100644 --- a/src/mongo/db/query/planner_access_test.cpp +++ b/src/mongo/db/query/planner_access_test.cpp @@ -38,7 +38,9 @@ namespace mongo { namespace { BSONObj serializeMatcher(Matcher* matcher) { - return matcher->getMatchExpression()->serialize(); + BSONObjBuilder builder; + matcher->getMatchExpression()->serialize(&builder); + return builder.obj(); } TEST(PlannerAccessTest, PrepareForAccessPlanningSortsEqualNodesByTheirChildren) { diff --git a/src/mongo/db/query/planner_analysis.cpp b/src/mongo/db/query/planner_analysis.cpp index ee86d426560..40d8d7b0d0d 100644 --- a/src/mongo/db/query/planner_analysis.cpp +++ b/src/mongo/db/query/planner_analysis.cpp @@ -337,7 +337,7 @@ void geoSkipValidationOn(const std::set<StringData>& twoDSphereFields, /** * If any field is missing from the list of fields the projection wants, we are not covered. */ -auto providesAllFields(const OrderedPathSet& fields, const QuerySolutionNode& solnRoot) { +auto providesAllFields(const std::set<std::string>& fields, const QuerySolutionNode& solnRoot) { for (auto&& field : fields) { if (!solnRoot.hasField(field)) return false; @@ -580,10 +580,6 @@ void removeProjectSimpleBelowGroupRecursive(QuerySolutionNode* solnRoot) { if (solnRoot->getType() == StageType::STAGE_GROUP) { auto groupNode = static_cast<GroupNode*>(solnRoot); - if (groupNode->needWholeDocument) { - // The sub expression needs the whole document. - return; - } auto projectNodeCandidate = groupNode->children[0]; if (projectNodeCandidate->getType() == StageType::STAGE_GROUP) { // Multiple $group stages may be pushed down. So, if the child is a GROUP, then recurse. diff --git a/src/mongo/db/query/planner_ixselect.cpp b/src/mongo/db/query/planner_ixselect.cpp index 755077517af..518da370750 100644 --- a/src/mongo/db/query/planner_ixselect.cpp +++ b/src/mongo/db/query/planner_ixselect.cpp @@ -245,7 +245,7 @@ static bool boundsGeneratingNodeContainsComparisonToType(MatchExpression* node, // static void QueryPlannerIXSelect::getFields(const MatchExpression* node, string prefix, - RelevantFieldIndexMap* out) { + stdx::unordered_set<string>* out) { // Do not traverse tree beyond a NOR negation node MatchExpression::MatchType exprtype = node->matchType(); if (exprtype == MatchExpression::NOR) { @@ -254,12 +254,16 @@ void QueryPlannerIXSelect::getFields(const MatchExpression* node, // Leaf nodes with a path and some array operators. if (Indexability::nodeCanUseIndexOnOwnField(node)) { - bool supportSparse = Indexability::nodeSupportedBySparseIndex(node); - (*out)[prefix + node->path().toString()] = {supportSparse}; - } else if (Indexability::isBoundsGeneratingElemMatchObject(node)) { + out->insert(prefix + node->path().toString()); + } else if (Indexability::arrayUsesIndexOnChildren(node)) { // If the array uses an index on its children, it's something like // {foo : {$elemMatch: {bar: 1}}}, in which case the predicate is really over foo.bar. - prefix += node->path().toString() + "."; + // + // When we have {foo: {$all: [{$elemMatch: {a: 1}}], the path of the embedded elemMatch + // is empty. We don't want to append a dot in that case as the field would be foo..a. + if (!node->path().empty()) { + prefix += node->path().toString() + "."; + } for (size_t i = 0; i < node->numChildren(); ++i) { getFields(node->getChild(i), prefix, out); @@ -271,7 +275,8 @@ void QueryPlannerIXSelect::getFields(const MatchExpression* node, } } -void QueryPlannerIXSelect::getFields(const MatchExpression* node, RelevantFieldIndexMap* out) { +void QueryPlannerIXSelect::getFields(const MatchExpression* node, + stdx::unordered_set<string>* out) { getFields(node, "", out); } @@ -311,40 +316,26 @@ std::vector<IndexEntry> QueryPlannerIXSelect::findIndexesByHint( // static std::vector<IndexEntry> QueryPlannerIXSelect::findRelevantIndices( - const RelevantFieldIndexMap& fields, const std::vector<IndexEntry>& allIndices) { + const stdx::unordered_set<std::string>& fields, const std::vector<IndexEntry>& allIndices) { std::vector<IndexEntry> out; - for (auto&& index : allIndices) { - BSONObjIterator it(index.keyPattern); + for (auto&& entry : allIndices) { + BSONObjIterator it(entry.keyPattern); BSONElement elt = it.next(); - const std::string fieldName = elt.fieldNameStringData().toString(); - - // If the index is non-sparse we can use the field regardless its sparsity, otherwise we - // should find the field that can be answered by a sparse index. - if (fields.contains(fieldName) && - (!index.sparse || fields.find(fieldName)->second.isSparse)) { - out.push_back(index); + if (fields.end() != fields.find(elt.fieldName())) { + out.push_back(entry); } } return out; } -std::vector<IndexEntry> QueryPlannerIXSelect::expandIndexes(const RelevantFieldIndexMap& fields, - std::vector<IndexEntry> relevantIndices, - bool indexHinted) { +std::vector<IndexEntry> QueryPlannerIXSelect::expandIndexes( + const stdx::unordered_set<std::string>& fields, std::vector<IndexEntry> relevantIndices) { std::vector<IndexEntry> out; - // Filter out fields that cannot be answered by any sparse index. We know wildcard indexes are - // sparse, so we don't want to expand the wildcard index based on such fields. - stdx::unordered_set<std::string> sparseIncompatibleFields; - for (auto&& [fieldName, idxProperty] : fields) { - if (idxProperty.isSparse || indexHinted) { - sparseIncompatibleFields.insert(fieldName); - } - } for (auto&& entry : relevantIndices) { if (entry.type == IndexType::INDEX_WILDCARD) { - wcp::expandWildcardIndexEntry(entry, sparseIncompatibleFields, &out); + wcp::expandWildcardIndexEntry(entry, fields, &out); } else { out.push_back(std::move(entry)); } @@ -789,8 +780,7 @@ void QueryPlannerIXSelect::_rateIndices(MatchExpression* node, childRt->path = rt->path; node->getChild(0)->setTag(childRt); } - } else if (Indexability::arrayUsesIndexOnChildren(node) && !node->path().empty()) { - // Note we skip empty path components since they are not allowed in index key patterns. + } else if (Indexability::arrayUsesIndexOnChildren(node)) { const auto newPath = prefix + node->path().toString(); ElemMatchContext newContext; // Note this StringData is unowned and references the string declared on the stack here. @@ -801,7 +791,12 @@ void QueryPlannerIXSelect::_rateIndices(MatchExpression* node, // If the array uses an index on its children, it's something like // {foo: {$elemMatch: {bar: 1}}}, in which case the predicate is really over foo.bar. - prefix += node->path().toString() + "."; + // + // When we have {foo: {$all: [{$elemMatch: {a: 1}}], the path of the embedded elemMatch + // is empty. We don't want to append a dot in that case as the field would be foo..a. + if (!node->path().empty()) { + prefix += node->path().toString() + "."; + } for (size_t i = 0; i < node->numChildren(); ++i) { _rateIndices(node->getChild(i), prefix, indices, collator, newContext); } @@ -924,10 +919,7 @@ void QueryPlannerIXSelect::stripUnneededAssignments(MatchExpression* node, */ static void removeIndexRelevantTag(MatchExpression* node, size_t idx) { RelevantTag* tag = static_cast<RelevantTag*>(node->getTag()); - if (!tag) { - return; - } - + verify(tag); vector<size_t>::iterator firstIt = std::find(tag->first.begin(), tag->first.end(), idx); if (firstIt != tag->first.end()) { tag->first.erase(firstIt); @@ -952,8 +944,9 @@ void stripInvalidAssignmentsToPartialIndexNode(MatchExpression* node, size_t idxNo, const IndexEntry& idxEntry, bool inNegationOrElemMatchObj) { - removeIndexRelevantTag(node, idxNo); - + if (node->getTag()) { + removeIndexRelevantTag(node, idxNo); + } inNegationOrElemMatchObj |= nodeIsNegationOrElemMatchObj(node); for (size_t i = 0; i < node->numChildren(); ++i) { // If 'node' is an OR and our current clause satisfies the filter expression, then we may be diff --git a/src/mongo/db/query/planner_ixselect.h b/src/mongo/db/query/planner_ixselect.h index 15f1e135d5e..0ef2d480953 100644 --- a/src/mongo/db/query/planner_ixselect.h +++ b/src/mongo/db/query/planner_ixselect.h @@ -38,24 +38,16 @@ namespace mongo { class CollatorInterface; -struct IndexProperties { - bool isSparse = false; // 'true' if a sparse index can answer the field. -}; - -// A relevant field to index requirement map. -using RelevantFieldIndexMap = stdx::unordered_map<std::string, IndexProperties>; - /** * Methods for determining what fields and predicates can use indices. */ class QueryPlannerIXSelect { public: /** - * Return all the fields in the tree rooted at 'node' that we can use an index to answer the - * query. The output, 'RelevantFieldIndexMap', contains the requirements of the index that can - * answer the field. e.g. Some fields can be supported only by a non-sparse index. + * Return all the fields in the tree rooted at 'node' that we can use an index on + * in order to answer the query. */ - static void getFields(const MatchExpression* node, RelevantFieldIndexMap* out); + static void getFields(const MatchExpression* node, stdx::unordered_set<std::string>* out); /** * Similar to other getFields() method, but with 'prefix' argument which is a path prefix to be @@ -65,7 +57,7 @@ public: */ static void getFields(const MatchExpression* node, std::string prefix, - RelevantFieldIndexMap* out); + stdx::unordered_set<std::string>* out); /** * Finds all indices that correspond to the hinted index. Matches the index both by name and by @@ -78,8 +70,8 @@ public: * Finds all indices prefixed by fields we have predicates over. Only these indices are * useful in answering the query. */ - static std::vector<IndexEntry> findRelevantIndices(const RelevantFieldIndexMap& fields, - const std::vector<IndexEntry>& allIndices); + static std::vector<IndexEntry> findRelevantIndices( + const stdx::unordered_set<std::string>& fields, const std::vector<IndexEntry>& allIndices); /** * Determine how useful all of our relevant 'indices' are to all predicates in the subtree @@ -138,12 +130,9 @@ public: /** * Given a list of IndexEntries and fields used by a query's match expression, return a list * "expanded" indexes (where the $** indexes in the given list have been expanded). - * 'hintedIndexBson' indicates that the indexes in 'relevantIndices' are the results of the - * user's hint. */ - static std::vector<IndexEntry> expandIndexes(const RelevantFieldIndexMap& fields, - std::vector<IndexEntry> relevantIndices, - bool hintedIndexBson = false); + static std::vector<IndexEntry> expandIndexes(const stdx::unordered_set<std::string>& fields, + std::vector<IndexEntry> relevantIndices); /** * Check if this match expression is a leaf and is supported by a wildcard index. diff --git a/src/mongo/db/query/planner_ixselect_test.cpp b/src/mongo/db/query/planner_ixselect_test.cpp index 1df4d714e67..93c4f12c821 100644 --- a/src/mongo/db/query/planner_ixselect_test.cpp +++ b/src/mongo/db/query/planner_ixselect_test.cpp @@ -65,20 +65,6 @@ unique_ptr<MatchExpression> parseMatchExpression(const BSONObj& obj) { return std::move(status.getValue()); } -using FieldIter = RelevantFieldIndexMap::iterator; -string toString(FieldIter begin, FieldIter end) { - str::stream ss; - ss << "["; - for (FieldIter i = begin; i != end; i++) { - if (i != begin) { - ss << " "; - } - ss << i->first; - } - ss << "]"; - return ss; -} - /** * Utility function to join elements in iterator range with comma */ @@ -102,13 +88,10 @@ string toString(Iter begin, Iter end) { * to QueryPlannerIXSelect::getFields() * Results are compared with expected fields (parsed from expectedFieldsStr) */ -void testGetFields(const char* query, - const char* prefix, - const char* expectedFieldsStr, - bool sparseSupported = true) { +void testGetFields(const char* query, const char* prefix, const char* expectedFieldsStr) { BSONObj obj = fromjson(query); unique_ptr<MatchExpression> expr(parseMatchExpression(obj)); - RelevantFieldIndexMap fields; + stdx::unordered_set<string> fields; QueryPlannerIXSelect::getFields(expr.get(), prefix, &fields); // Verify results @@ -116,7 +99,7 @@ void testGetFields(const char* query, vector<string> expectedFields = StringSplitter::split(expectedFieldsStr, ","); for (vector<string>::const_iterator i = expectedFields.begin(); i != expectedFields.end(); i++) { - if (fields[*i].isSparse != sparseSupported) { + if (fields.find(*i) == fields.end()) { str::stream ss; ss << "getFields(query=" << query << ", prefix=" << prefix << "): unable to find " << *i << " in result: " << toString(fields.begin(), fields.end()); @@ -176,12 +159,6 @@ TEST(QueryPlannerIXSelectTest, GetFieldsArrayNegation) { testGetFields("{a: {$all: [{$elemMatch: {b: {$ne: 1}}}]}}", "", "a.b"); } -TEST(QueryPlannerIXSelectTest, GetFieldsInternalExpr) { - testGetFields("{$expr: {$lt: ['$a', 'r']}}", "", "", false /* sparse supported */); - testGetFields("{$expr: {$eq: ['$a', null]}}", "", "", false /* sparse supported */); - testGetFields("{$expr: {$eq: ['$a', 1]}}", "", "", false /* sparse supported */); -} - /** * Performs a pre-order traversal of expression tree. Validates * that all tagged nodes contain an instance of RelevantTag. @@ -1176,6 +1153,25 @@ TEST(QueryPlannerIXSelectTest, InternalExprEqCanUseTextIndexSuffix) { "{a: {$_internalExprEq: 1}}", "", kSimpleCollator, indices, "a", expectedIndices); } +TEST(QueryPlannerIXSelectTest, InternalExprEqCanUseSparseIndexWithComparisonToNull) { + auto entry = buildSimpleIndexEntry(BSON("a" << 1)); + entry.sparse = true; + std::vector<IndexEntry> indices; + indices.push_back(entry); + std::set<size_t> expectedIndices = {0}; + testRateIndices( + "{a: {$_internalExprEq: null}}", "", kSimpleCollator, indices, "a", expectedIndices); +} + +TEST(QueryPlannerIXSelectTest, InternalExprEqCanUseSparseIndexWithComparisonToNonNull) { + auto entry = buildSimpleIndexEntry(BSON("a" << 1)); + entry.sparse = true; + std::vector<IndexEntry> indices; + indices.push_back(entry); + std::set<size_t> expectedIndices = {0}; + testRateIndices( + "{a: {$_internalExprEq: 1}}", "", kSimpleCollator, indices, "a", expectedIndices); +} TEST(QueryPlannerIXSelectTest, NotEqualsNullCanUseIndex) { auto entry = buildSimpleIndexEntry(BSON("a" << 1)); std::set<size_t> expectedIndices = {0}; @@ -1361,17 +1357,18 @@ TEST(QueryPlannerIXSelectTest, ExpandWildcardIndices) { const auto indexEntry = makeIndexEntry(BSON("$**" << 1), {}); // Case where no fields are specified. - std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes({}, {indexEntry.first}); + std::vector<IndexEntry> result = + QueryPlannerIXSelect::expandIndexes(stdx::unordered_set<string>(), {indexEntry.first}); ASSERT_TRUE(result.empty()); - RelevantFieldIndexMap fields = {{"fieldA", {true}}, {"fieldB", {true}}}; + stdx::unordered_set<string> fields = {"fieldA", "fieldB"}; result = QueryPlannerIXSelect::expandIndexes(fields, {indexEntry.first}); std::vector<BSONObj> expectedKeyPatterns = {BSON("fieldA" << 1), BSON("fieldB" << 1)}; ASSERT_TRUE(indexEntryKeyPatternsMatch(&expectedKeyPatterns, &result)); const auto wildcardIndexWithSubpath = makeIndexEntry(BSON("a.b.$**" << 1), {}); - fields = {{"a.b", {true}}, {"a.b.c", {true}}, {"a.d", {true}}}; + fields = {"a.b", "a.b.c", "a.d"}; result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexWithSubpath.first}); expectedKeyPatterns = {BSON("a.b" << 1), BSON("a.b.c" << 1)}; ASSERT_TRUE(indexEntryKeyPatternsMatch(&expectedKeyPatterns, &result)); @@ -1383,8 +1380,7 @@ TEST(QueryPlannerIXSelectTest, ExpandWildcardIndicesInPresenceOfOtherIndices) { auto bIndexEntry = makeIndexEntry(BSON("fieldB" << 1), {}); auto abIndexEntry = makeIndexEntry(BSON("fieldA" << 1 << "fieldB" << 1), {}); - const RelevantFieldIndexMap fields = { - {"fieldA", {true}}, {"fieldB", {true}}, {"fieldC", {true}}}; + const stdx::unordered_set<string> fields = {"fieldA", "fieldB", "fieldC"}; std::vector<BSONObj> expectedKeyPatterns = { BSON("fieldA" << 1), BSON("fieldA" << 1), BSON("fieldB" << 1), BSON("fieldC" << 1)}; @@ -1422,7 +1418,7 @@ TEST(QueryPlannerIXSelectTest, ExpandWildcardIndicesInPresenceOfOtherIndices) { TEST(QueryPlannerIXSelectTest, ExpandedIndexEntriesAreCorrectlyMarkedAsMultikeyOrNonMultikey) { auto wildcardIndexEntry = makeIndexEntry(BSON("$**" << 1), {}, {FieldRef{"a"}}); - RelevantFieldIndexMap fields = {{"a.b", {true}}, {"c.d", {true}}}; + const stdx::unordered_set<string> fields = {"a.b", "c.d"}; std::vector<BSONObj> expectedKeyPatterns = {BSON("a.b" << 1), BSON("c.d" << 1)}; auto result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1446,7 +1442,7 @@ TEST(QueryPlannerIXSelectTest, ExpandedIndexEntriesAreCorrectlyMarkedAsMultikeyO TEST(QueryPlannerIXSelectTest, WildcardIndexExpansionExcludesIdField) { const auto indexEntry = makeIndexEntry(BSON("$**" << 1), {}); - RelevantFieldIndexMap fields = {{"_id", {true}}, {"abc", {true}}, {"def", {true}}}; + stdx::unordered_set<string> fields = {"_id", "abc", "def"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {indexEntry.first}); @@ -1458,7 +1454,7 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesExpandedEntryHasCorrectProperties) auto wildcardIndexEntry = makeIndexEntry(BSON("$**" << 1), {}); wildcardIndexEntry.first.identifier = IndexEntry::Identifier("someIndex"); - RelevantFieldIndexMap fields = {{"abc", {true}}, {"def", {true}}}; + stdx::unordered_set<string> fields = {"abc", "def"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1488,11 +1484,7 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesExpandedEntryHasCorrectProperties) TEST(QueryPlannerIXSelectTest, WildcardIndicesExcludeNonMatchingKeySubpath) { auto wildcardIndexEntry = makeIndexEntry(BSON("subpath.$**" << 1), {}); - RelevantFieldIndexMap fields = {{"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = {"abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1508,11 +1500,7 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesExcludeNonMatchingPathsWithInclusi {}, BSON("wildcardProjection" << BSON("abc" << 1 << "subpath.abc" << 1))); - RelevantFieldIndexMap fields = {{"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = {"abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1527,11 +1515,7 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesExcludeNonMatchingPathsWithExclusi {}, BSON("wildcardProjection" << BSON("abc" << 0 << "subpath.abc" << 0))); - RelevantFieldIndexMap fields = {{"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = {"abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1547,12 +1531,8 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesWithInclusionProjectionAllowIdExcl {}, BSON("wildcardProjection" << BSON("_id" << 0 << "abc" << 1 << "subpath.abc" << 1))); - RelevantFieldIndexMap fields = {{"_id", {true}}, - {"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = { + "_id", "abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1567,12 +1547,8 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesWithInclusionProjectionAllowIdIncl {}, BSON("wildcardProjection" << BSON("_id" << 1 << "abc" << 1 << "subpath.abc" << 1))); - RelevantFieldIndexMap fields = {{"_id", {true}}, - {"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = { + "_id", "abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1588,12 +1564,8 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesWithExclusionProjectionAllowIdIncl {}, BSON("wildcardProjection" << BSON("_id" << 1 << "abc" << 0 << "subpath.abc" << 0))); - RelevantFieldIndexMap fields = {{"_id", {true}}, - {"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = { + "_id", "abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); @@ -1606,12 +1578,8 @@ TEST(QueryPlannerIXSelectTest, WildcardIndicesIncludeMatchingInternalNodes) { auto wildcardIndexEntry = makeIndexEntry( BSON("$**" << 1), {}, {}, BSON("wildcardProjection" << BSON("_id" << 1 << "subpath" << 1))); - RelevantFieldIndexMap fields = {{"_id", {true}}, - {"abc", {true}}, - {"def", {true}}, - {"subpath.abc", {true}}, - {"subpath.def", {true}}, - {"subpath", {true}}}; + stdx::unordered_set<string> fields = { + "_id", "abc", "def", "subpath.abc", "subpath.def", "subpath"}; std::vector<IndexEntry> result = QueryPlannerIXSelect::expandIndexes(fields, {wildcardIndexEntry.first}); diff --git a/src/mongo/db/query/projection.cpp b/src/mongo/db/query/projection.cpp index 2646b39bd8c..af5fedfe780 100644 --- a/src/mongo/db/query/projection.cpp +++ b/src/mongo/db/query/projection.cpp @@ -49,7 +49,7 @@ struct DepsAnalysisData { fieldDependencyTracker.fields.insert(fieldName); } - OrderedPathSet requiredFields() const { + std::set<std::string> requiredFields() const { return fieldDependencyTracker.fields; } }; @@ -227,13 +227,6 @@ void optimizeProjection(ProjectionPathASTNode* root) { Projection::Projection(ProjectionPathASTNode root, ProjectType type) : _root(std::move(root)), _type(type), _deps(analyzeProjection(&_root, type)) {} -void Projection::optimize() { - if (!_projOptimized) { - optimizeProjection(&_root); - _deps = analyzeProjection(&_root, _type); - _projOptimized = true; - } -} namespace { /** diff --git a/src/mongo/db/query/projection.h b/src/mongo/db/query/projection.h index 95d41caba02..914567e87ed 100644 --- a/src/mongo/db/query/projection.h +++ b/src/mongo/db/query/projection.h @@ -49,7 +49,7 @@ struct ProjectionDependencies { bool containsElemMatch = false; // Which fields are necessary to perform the projection, or boost::none if all are required. - boost::optional<OrderedPathSet> requiredFields; + boost::optional<std::set<std::string>> requiredFields; bool hasDottedPath = false; @@ -95,7 +95,7 @@ public: * Return which fields are required to compute the projection, assuming the entire document is * not needed. */ - const OrderedPathSet& getRequiredFields() const { + const std::set<std::string>& getRequiredFields() const { invariant(_type == ProjectType::kInclusion); return *_deps.requiredFields; } @@ -142,25 +142,14 @@ public: return _deps.containsElemMatch; } - /** - * Optimizes the projection tree. Additionally, re-computes dependencies in case anything - * changes as in projection {x: {$and: [false, "$b"]}} - which when optimized will no longer - * depend on "b". - */ - void optimize(); - private: ProjectionPathASTNode _root; ProjectType _type; ProjectionDependencies _deps; - bool _projOptimized = false; }; /** - * Walks the projection AST and optimizes each node. Note if you have a 'Projection' instance you - * should prefer to use Projection::optimize() since it will additionally re-compute dependencies in - * case anything changes as in projection {x: {$and: [false, "$b"]}} - which when optimized will no - * longer depend on "b". + * Walks the projection AST and optimizes each node. */ void optimizeProjection(ProjectionPathASTNode* root); diff --git a/src/mongo/db/query/projection_ast.h b/src/mongo/db/query/projection_ast.h index 1304c68efe5..247a91537f3 100644 --- a/src/mongo/db/query/projection_ast.h +++ b/src/mongo/db/query/projection_ast.h @@ -275,7 +275,7 @@ public: ExpressionASTNode(boost::intrusive_ptr<Expression> expr) : _expr(expr) {} ExpressionASTNode(const ExpressionASTNode& other) : ASTNode(other) { BSONObjBuilder bob; - bob << "" << other._expr->serialize(); + bob << "" << other._expr->serialize(false); // TODO SERVER-31003: add a clone() method to Expression. // Temporary stop expression counters while processing the cloned expression. diff --git a/src/mongo/db/query/projection_ast_test.cpp b/src/mongo/db/query/projection_ast_test.cpp index ea1eb2b683d..619bd9a1dde 100644 --- a/src/mongo/db/query/projection_ast_test.cpp +++ b/src/mongo/db/query/projection_ast_test.cpp @@ -41,7 +41,6 @@ #include "mongo/db/query/projection_ast_util.h" #include "mongo/db/query/projection_parser.h" #include "mongo/db/query/query_planner_test_fixture.h" -#include "mongo/db/query/query_shape/serialization_options.h" namespace { @@ -773,62 +772,4 @@ TEST_F(ProjectionASTTest, ShouldThrowWithPositionalOnExclusion) { DBException, 31395); } - -TEST_F(ProjectionASTTest, TestASTRedaction) { - SerializationOptions options = SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST; - - auto proj = fromjson("{'a.b': 1}"); - BSONObj output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<a>":{"HASH<b>":true},"HASH<_id>":true})", - output); - - proj = fromjson("{'a.b': 0}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<a>":{"HASH<b>":false}})", - output); - - proj = fromjson("{a: 1, b: 1}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<a>":true,"HASH<b>":true,"HASH<_id>":true})", - output); - - // ElemMatch projection - proj = fromjson("{f: {$elemMatch: {foo: 'bar'}}}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<f>":{"$elemMatch":{"HASH<foo>":{"$eq":"?string"}}},"HASH<_id>":true})", - output); - - // Positional projection - proj = fromjson("{'x.$': 1}"); - output = projection_ast::serialize( - *parseWithFindFeaturesEnabled(proj, fromjson("{'x.a': 2}")).root(), {}); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"x.$":true,"_id":true})", - output); - - // Slice (first form) - proj = fromjson("{a: {$slice: 1}}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<a>":{"$slice":"?number"}})", - output); - - // Slice (second form) - proj = fromjson("{a: {$slice: [1, 3]}}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<a>":{"$slice":["?number","?number"]}})", - output); - - /// $meta projection - proj = fromjson("{foo: {$meta: 'indexKey'}}"); - output = projection_ast::serialize(*parseWithFindFeaturesEnabled(proj).root(), options); - ASSERT_BSONOBJ_EQ_AUTO( // - R"({"HASH<foo>":{"$meta":"indexKey"}})", - output); -} } // namespace diff --git a/src/mongo/db/query/projection_ast_util.cpp b/src/mongo/db/query/projection_ast_util.cpp index 23c7b6d9582..e5b4cc1a9c4 100644 --- a/src/mongo/db/query/projection_ast_util.cpp +++ b/src/mongo/db/query/projection_ast_util.cpp @@ -29,26 +29,28 @@ #include "mongo/platform/basic.h" -#include "mongo/db/query/projection_ast_path_tracking_visitor.h" #include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/query_shape/serialization_options.h" + +#include "mongo/db/query/projection_ast_path_tracking_visitor.h" #include "mongo/db/query/tree_walker.h" namespace mongo::projection_ast { namespace { struct BSONVisitorContext { std::stack<BSONObjBuilder> builders; - bool underElemMatch = false; }; class BSONPreVisitor : public ProjectionASTConstVisitor { public: - using ProjectionASTConstVisitor::visit; - BSONPreVisitor(PathTrackingVisitorContext<BSONVisitorContext>* context, - SerializationOptions options) - : _context(context), _builders(context->data().builders), _options(std::move(options)) {} + BSONPreVisitor(PathTrackingVisitorContext<BSONVisitorContext>* context) + : _context(context), _builders(context->data().builders) {} + + virtual void visit(const MatchExpressionASTNode* node) { + static_cast<const MatchExpressionASTNode*>(node)->matchExpression()->serialize( + &_builders.top(), true); + } - void visit(const ProjectionPathASTNode* node) override { + virtual void visit(const ProjectionPathASTNode* node) { if (!node->parent()) { // No root of the tree, thus this node has no field name. _builders.push(BSONObjBuilder()); @@ -57,46 +59,47 @@ public: } } - void visit(const ProjectionSliceASTNode* node) override { + virtual void visit(const ProjectionPositionalASTNode* node) { + // ProjectionPositional always has the original query's match expression node as its + // child. Serialize as: {"positional.projection.field.$": <original match expression>}. + _context->data().builders.push(_builders.top().subobjStart(getFieldName() + ".$")); + } + + virtual void visit(const ProjectionSliceASTNode* node) { BSONObjBuilder sub(_builders.top().subobjStart(getFieldName())); if (node->skip()) { - sub.appendArray("$slice", - BSON_ARRAY(_options.serializeLiteral(*node->skip()) - << _options.serializeLiteral(node->limit()))); + sub.appendArray("$slice", BSON_ARRAY(*node->skip() << node->limit())); } else { - _options.appendLiteral(&sub, "$slice", node->limit()); + sub.appendNumber("$slice", node->limit()); } } + virtual void visit(const ProjectionElemMatchASTNode* node) { + // Defer to the child, match expression node. + } - void visit(const ExpressionASTNode* node) override { - node->expression()->serialize(_options).addToBsonObj(&_builders.top(), getFieldName()); + virtual void visit(const ExpressionASTNode* node) { + node->expression()->serialize(false).addToBsonObj(&_builders.top(), getFieldName()); } - void visit(const BooleanConstantASTNode* node) override { + virtual void visit(const BooleanConstantASTNode* node) { _builders.top().append(getFieldName(), node->value()); } - void visit(const ProjectionPositionalASTNode* node) override = 0; - void visit(const ProjectionElemMatchASTNode* node) override = 0; - void visit(const MatchExpressionASTNode* node) override = 0; - -protected: +private: std::string getFieldName() { - return _options.serializeFieldPathFromString(_context->childPath()); + return _context->childPath(); } PathTrackingVisitorContext<BSONVisitorContext>* _context; std::stack<BSONObjBuilder>& _builders; - SerializationOptions _options; }; class BSONPostVisitor : public ProjectionASTConstVisitor { public: - using ProjectionASTConstVisitor::visit; BSONPostVisitor(BSONVisitorContext* context) : _context(context) {} - void visit(const ProjectionPathASTNode* node) override { + virtual void visit(const ProjectionPathASTNode* node) { // Don't pop the top builder. if (node->parent()) { // Pop the BSONObjBuilder that was added in the pre visitor. @@ -104,97 +107,25 @@ public: } } - void visit(const ProjectionSliceASTNode* node) override {} - void visit(const ExpressionASTNode* node) override {} - void visit(const BooleanConstantASTNode* node) override {} - void visit(const MatchExpressionASTNode* node) override {} - - void visit(const ProjectionPositionalASTNode* node) override = 0; - void visit(const ProjectionElemMatchASTNode* node) override = 0; - -protected: - BSONVisitorContext* _context; -}; - -class DebugPreVisitor : public BSONPreVisitor { -public: - using BSONPreVisitor::visit; - DebugPreVisitor(PathTrackingVisitorContext<BSONVisitorContext>* context) - : BSONPreVisitor(context, SerializationOptions{}) {} - - void visit(const ProjectionPositionalASTNode* node) override { - // ProjectionPositional always has the original query's match expression node as its - // child. Serialize as: {"positional.projection.field.$": <original match expression>}. - _context->data().builders.push(_builders.top().subobjStart(getFieldName() + ".$")); - } - - void visit(const ProjectionElemMatchASTNode* node) override { - // Defer to the child, match expression node. - } - - void visit(const MatchExpressionASTNode* node) override { - static_cast<const MatchExpressionASTNode*>(node)->matchExpression()->serialize( - &_builders.top(), {}); - } -}; - -class DebugPostVisitor : public BSONPostVisitor { -public: - using BSONPostVisitor::visit; - DebugPostVisitor(BSONVisitorContext* context) : BSONPostVisitor(context) {} - - void visit(const ProjectionPositionalASTNode* node) override { + virtual void visit(const ProjectionPositionalASTNode* node) { _context->builders.pop(); } - void visit(const ProjectionElemMatchASTNode* node) override {} -}; + virtual void visit(const MatchExpressionASTNode* node) {} + virtual void visit(const ProjectionSliceASTNode* node) {} + virtual void visit(const ProjectionElemMatchASTNode* node) {} + virtual void visit(const ExpressionASTNode* node) {} + virtual void visit(const BooleanConstantASTNode* node) {} -class SerializationPreVisitor : public BSONPreVisitor { -public: - using BSONPreVisitor::visit; - SerializationPreVisitor(PathTrackingVisitorContext<BSONVisitorContext>* context, - const SerializationOptions& options) - : BSONPreVisitor(context, options) {} - - void visit(const ProjectionPositionalASTNode* node) override { - tassert(73488, - "Positional projection should not appear below an $elemMatch projection.", - !_context->data().underElemMatch); - _builders.top().append(getFieldName() + ".$", true); - } - - void visit(const ProjectionElemMatchASTNode* node) override { - // The child match expression node should begin with $elemMatch. - _context->data().underElemMatch = true; - } - - void visit(const MatchExpressionASTNode* node) override { - if (_context->data().underElemMatch) { - static_cast<const MatchExpressionASTNode*>(node)->matchExpression()->serialize( - &_builders.top(), _options); - } - } -}; - -class SerializationPostVisitor : public BSONPostVisitor { -public: - using BSONPostVisitor::visit; - SerializationPostVisitor(BSONVisitorContext* context) : BSONPostVisitor(context) {} - - void visit(const ProjectionPositionalASTNode* node) override {} - void visit(const ProjectionElemMatchASTNode* node) override { - _context->underElemMatch = false; - } +private: + BSONVisitorContext* _context; }; - } // namespace BSONObj astToDebugBSON(const ASTNode* root) { PathTrackingVisitorContext<BSONVisitorContext> context; - DebugPreVisitor preVisitor{&context}; - DebugPostVisitor postVisitor{&context.data()}; - + BSONPreVisitor preVisitor{&context}; + BSONPostVisitor postVisitor{&context.data()}; PathTrackingWalker walker{&context, {&preVisitor}, {&postVisitor}}; tree_walker::walk<true, projection_ast::ASTNode>(root, &walker); @@ -202,15 +133,4 @@ BSONObj astToDebugBSON(const ASTNode* root) { invariant(context.data().builders.size() == 1); return context.data().builders.top().obj(); } - -BSONObj serialize(const ProjectionPathASTNode& root, const SerializationOptions& options) { - PathTrackingVisitorContext<BSONVisitorContext> context; - SerializationPreVisitor preVisitor{&context, options}; - SerializationPostVisitor postVisitor{&context.data()}; - PathTrackingWalker walker{&context, {&preVisitor}, {&postVisitor}}; - tree_walker::walk<true, projection_ast::ASTNode>(&root, &walker); - - invariant(context.data().builders.size() == 1); - return context.data().builders.top().obj(); -} } // namespace mongo::projection_ast diff --git a/src/mongo/db/query/projection_ast_util.h b/src/mongo/db/query/projection_ast_util.h index de102dfbbd7..af89254a9a1 100644 --- a/src/mongo/db/query/projection_ast_util.h +++ b/src/mongo/db/query/projection_ast_util.h @@ -29,7 +29,6 @@ #pragma once -#include "mongo/db/query/projection.h" #include "mongo/db/query/projection_ast.h" namespace mongo { @@ -38,7 +37,5 @@ namespace projection_ast { * This is intended to be used for debug output, not for serialization. */ BSONObj astToDebugBSON(const ASTNode* root); - -BSONObj serialize(const ProjectionPathASTNode& root, const SerializationOptions& options); } // namespace projection_ast } // namespace mongo diff --git a/src/mongo/db/query/projection_parser.cpp b/src/mongo/db/query/projection_parser.cpp index 3495f99f8f2..afb3c12556e 100644 --- a/src/mongo/db/query/projection_parser.cpp +++ b/src/mongo/db/query/projection_parser.cpp @@ -510,16 +510,7 @@ void parseSubObject(ParseContext* ctx, // It was likely intended to be an expression. Check if it's a valid field path or not to // confirm. try { - const auto elementFieldName = obj.firstElementFieldNameStringData(); - if (!hasPositionalOperator(elementFieldName)) { - FieldPath fp(elementFieldName); - } else { - // The 'FieldPath' parser doesn't take positional operators into account, but those - // are valid path projections so trim it off for this validation. - StringData pathWithoutPositionalOperator = - elementFieldName.substr(0, elementFieldName.size() - 2); - FieldPath fp(pathWithoutPositionalOperator); - } + FieldPath fp(obj.firstElementFieldNameStringData()); } catch (const DBException&) { uasserted(31325, str::stream() @@ -640,8 +631,10 @@ Projection parseAndAnalyze(boost::intrusive_ptr<ExpressionContext> expCtx, invariant(root.removeChild("_id")); } - // Optimize the projection expression if requested. - if (shouldOptimize) { + // Optimize the projection expression if requested and as long as not explicitly disabled + // pipeline optimization. + auto fp = globalFailPointRegistry().find("disablePipelineOptimization"); + if (shouldOptimize && !(fp && fp->shouldFail())) { optimizeProjection(&root); } diff --git a/src/mongo/db/query/query_feature_flags.idl b/src/mongo/db/query/query_feature_flags.idl index 7e5995a022f..5ac4a341a2c 100644 --- a/src/mongo/db/query/query_feature_flags.idl +++ b/src/mongo/db/query/query_feature_flags.idl @@ -107,12 +107,6 @@ feature_flags: default: true version: 5.3 - featureFlagChangeStreamsFurtherEnrichedEvents: - description: "Feature flag for enabling the reshardCollection and refineCollectionShardKey events, as well as enhancements to the updateDescription field for update events" - cpp_varname: gFeatureFlagChangeStreamsFurtherEnrichedEvents - default: true - version: 6.0 - featureFlagCommonQueryFramework: description: "Feature flag for allowing use of Cascades-based query optimizer" cpp_varname: gfeatureFlagCommonQueryFramework @@ -151,27 +145,3 @@ feature_flags: description: "Feature flag to enable using SBE for a larger number of queries" cpp_varname: gFeatureFlagSbeFull default: false - - featureFlagQueryStats: - description: "Feature flag for enabling full queryStats collection." - cpp_varname: gFeatureFlagQueryStats - default: true - version: 6.0 - - featureFlagShardedSearchCustomSort: - description: "Feature flag to enable user specified sort for sharded $search queries." - cpp_varname: gFeatureFlagShardedSearchCustomSort - default: true - version: 6.0 - - featureFlagSearchBatchSizeLimit: - description: "Feature flag to enable the search batchsize and limit optimization." - cpp_varname: gFeatureFlagSearchBatchSizeLimit - default: true - version: 6.0 - - featureFlagVectorSearchPublicPreview: - description: "Feature flag to enable vector search for public preview." - cpp_varname: gFeatureFlagVectorSearchPublicPreview - default: true - version: 6.0 diff --git a/src/mongo/db/query/query_knobs.idl b/src/mongo/db/query/query_knobs.idl index f0f24d3c3dd..f894629037f 100644 --- a/src/mongo/db/query/query_knobs.idl +++ b/src/mongo/db/query/query_knobs.idl @@ -29,9 +29,8 @@ global: cpp_namespace: "mongo" cpp_includes: + - "mongo/db/query/plan_cache_size_parameter.h" - "mongo/db/query/sbe_plan_cache_on_parameter_change.h" - - "mongo/db/query/util/memory_util.h" - - "mongo/db/query/query_stats/query_stats_on_parameter_change.h" - "mongo/platform/atomic_proxy.h" - "mongo/platform/atomic_word.h" @@ -101,15 +100,6 @@ server_parameters: gte: 0 on_update: plan_cache_util::clearSbeCacheOnParameterChange - internalQueryPlanTieBreakingWithIndexHeuristics: - description: "Tie-breaking rules which choose the plan that fetches the smallest number of - documents or examines fewest index keys, as well as one that can be assigned the longest - contiguous prefix of equality predicates in any index." - set_at: [ startup, runtime ] - cpp_varname: "internalQueryPlanTieBreakingWithIndexHeuristics" - cpp_vartype: AtomicWord<bool> - default: true - internalQueryForceIntersectionPlans: description: "Gives a large ranking bonus to index intersection plans, forcing intersection plans to be chosen when possible." @@ -421,7 +411,7 @@ server_parameters: cpp_varname: "internalInsertMaxBatchSize" cpp_vartype: AtomicWord<int> default: - expr: 64 + expr: internalQueryExecYieldIterations.load() / 2 is_constexpr: false validator: gt: 0 @@ -636,13 +626,6 @@ server_parameters: validator: gt: 0 - internalQuerySlotBasedExecutionHashAggForceIncreasedSpilling: - description: "If true, the HashAgg stage will perform increased spilling." - set_at: [ startup, runtime ] - cpp_varname: "internalQuerySlotBasedExecutionHashAggForceIncreasedSpilling" - cpp_vartype: AtomicWord<bool> - default: false - internalQuerySlotBasedExecutionHashLookupApproxMemoryUseInBytesBeforeSpill: description: "The max size in bytes that the hash table in a HashLookup stage can be estimated to be before we spill to disk." @@ -676,7 +659,7 @@ server_parameters: set_at: [ startup, runtime ] cpp_varname: "internalQueryForceClassicEngine" cpp_vartype: AtomicWord<bool> - default: true + default: false internalQueryAppendIdToSetWindowFieldsSort: description: "If true, appends _id to the sort stage generated by desugaring $setWindowFields to @@ -888,88 +871,6 @@ server_parameters: default: expr: false - internalQueryGlobalProfilingFilter: - description: "Enables the setProfilingFilterGlobally command." - set_at: [ startup ] - cpp_varname: internalQueryGlobalProfilingFilter - cpp_vartype: AtomicWord<bool> - default: false - - - internalQueryDocumentSourceWriterBatchExtraReservedBytes: - description: "Space to reserve in document source writer batches for miscellaneous metadata" - set_at: [ startup, runtime ] - cpp_vartype: AtomicWord<int> - cpp_varname: internalQueryDocumentSourceWriterBatchExtraReservedBytes - validator: - gte: 0 - lte: - expr: 8 * 1024 * 1024 # 8MB - default: 0 - - internalQueryStatsRateLimit: - description: "The maximum number of queries per second that are sampled for query stats. - If the rate of queries goes above this number, then rate limiting will kick in, and any - further queries will not be sampled. To sample all queries, this can be set to -1. This can be - set to 0 to turn queryStats off completely." - set_at: [ startup, runtime ] - cpp_varname: "internalQueryStatsRateLimit" - cpp_vartype: AtomicWord<int> - default: 0 - validator: - gte: -1 - on_update: query_stats_util::onQueryStatsSamplingRateUpdate - - internalQueryStatsCacheSize: - description: "The maximum amount of memory that the system will allocate for the query queryStats - cache. This will accept values in either of the following formats: - 1. <number>% indicates a percentage of the physical memory available to the process. E.g.: 15%. - 2. <number>(MB|GB), indicates the amount of memory in MB or GB. E.g.: 1.5GB, 100MB. - The default value is 1%, which means 1% of the physical memory available to the process." - set_at: [ startup, runtime ] - cpp_varname: "internalQueryStatsCacheSize" - cpp_vartype: synchronized_value<std::string> - default: "1%" - on_update: query_stats_util::onQueryStatsStoreSizeUpdate - validator: - callback: query_stats_util::validateQueryStatsStoreSize - - internalQueryStatsErrorsAreCommandFatal: - description: "Whether errors in the $queryStats stage cause the aggregation pipeline to - immediately fail and report the error. Note that this is always the case for debug builds." - set_at: [ startup, runtime ] - cpp_varname: "internalQueryStatsErrorsAreCommandFatal" - cpp_vartype: AtomicWord<bool> - default: false - - internalQueryAggMulticastTimeoutMS: - description: "Timeout in MS for requests to shard servers when aggregations are sent to all shard servers" - set_at: [ startup ] - cpp_vartype: int - cpp_varname: internalQueryAggMulticastTimeoutMS - default: 60000 - validator: - gte: 0 - - internalQueryAggMulticastMaxConcurrency: - description: "Max number of concurrent requests when aggregations are sent to all shard servers" - set_at: startup - cpp_vartype: int - cpp_varname: internalQueryAggMulticastMaxConcurrency - default: 100 - validator: - gte: 1 - - internalQuerySpillingMaxWaitTimeout: - description: "Timeout in MS that the storage engine will block a spilling operation when the - cache is under pressure." - set_at: [ startup, runtime ] - cpp_vartype: AtomicWord<int> - cpp_varname: internalQuerySpillingMaxWaitTimeout - default: 1000 - validator: - gte: 0 - # Note for adding additional query knobs: # # When adding a new query knob, you should consider whether or not you need to add an 'on_update' diff --git a/src/mongo/db/query/query_planner.cpp b/src/mongo/db/query/query_planner.cpp index 32af6762a17..c258c9e6867 100644 --- a/src/mongo/db/query/query_planner.cpp +++ b/src/mongo/db/query/query_planner.cpp @@ -252,11 +252,6 @@ void tryToAddColumnScan(const QueryPlannerParams& params, // collection scan. Add that solution. out.push_back(QueryPlannerAnalysis::analyzeDataAccess(query, params, std::move(columnScan))); } - -bool collscanIsBounded(const CollectionScanNode* collscan) { - return collscan->minRecord || collscan->maxRecord; -} - } // namespace using std::numeric_limits; @@ -339,9 +334,6 @@ string optionString(size_t options) { case QueryPlannerParams::RETURN_OWNED_DATA: ss << "RETURN_OWNED_DATA "; break; - case QueryPlannerParams::STRICT_NO_TABLE_SCAN: - ss << "STRICT_NO_TABLE_SCAN "; - break; case QueryPlannerParams::DEFAULT: MONGO_UNREACHABLE; break; @@ -477,57 +469,13 @@ static BSONObj finishMaxObj(const IndexEntry& indexEntry, } } -bool providesSort(const CanonicalQuery& query, const BSONObj& kp) { - return query.getFindCommandRequest().getSort().isPrefixOf( - kp, SimpleBSONElementComparator::kInstance); -} - -/** - * Determine whether this query has a sort that can be provided by the clustered index, if so, which - * direction the scan should be. If the collection is not clustered, or the sort cannot be provided, - * returns 'boost::none'. - */ -boost::optional<int> determineClusteredScanDirection(const CanonicalQuery& query, - const QueryPlannerParams& params) { - if (params.clusteredInfo && query.getSortPattern() && - CollatorInterface::collatorsMatch(params.clusteredCollectionCollator, - query.getCollator())) { - auto kp = clustered_util::getSortPattern(params.clusteredInfo->getIndexSpec()); - if (providesSort(query, kp)) { - return 1; - } else if (providesSort(query, QueryPlannerCommon::reverseSortObj(kp))) { - return -1; - } - } - - return boost::none; -} - -/** - * Determine the direction of the scan needed for the query. Defaults to 1 unless this is a - * clustered collection and we have a sort that can be provided by the clustered index. - */ -int determineCollscanDirection(const CanonicalQuery& query, const QueryPlannerParams& params) { - return determineClusteredScanDirection(query, params).value_or(1); -} - -std::pair<std::unique_ptr<QuerySolution>, const CollectionScanNode*> buildCollscanSolnWithNode( - const CanonicalQuery& query, - bool tailable, - const QueryPlannerParams& params, - boost::optional<int> direction = boost::none) { - std::unique_ptr<QuerySolutionNode> solnRoot(QueryPlannerAccess::makeCollectionScan( - query, tailable, params, direction.value_or(determineCollscanDirection(query, params)))); - const auto* collscanNode = checked_cast<const CollectionScanNode*>(solnRoot.get()); - return std::make_pair( - QueryPlannerAnalysis::analyzeDataAccess(query, params, std::move(solnRoot)), collscanNode); -} - std::unique_ptr<QuerySolution> buildCollscanSoln(const CanonicalQuery& query, bool tailable, const QueryPlannerParams& params, - boost::optional<int> direction = boost::none) { - return buildCollscanSolnWithNode(query, tailable, params, direction).first; + int direction = 1) { + std::unique_ptr<QuerySolutionNode> solnRoot( + QueryPlannerAccess::makeCollectionScan(query, tailable, params, direction)); + return QueryPlannerAnalysis::analyzeDataAccess(query, params, std::move(solnRoot)); } std::unique_ptr<QuerySolution> buildWholeIXSoln( @@ -543,6 +491,11 @@ std::unique_ptr<QuerySolution> buildWholeIXSoln( return QueryPlannerAnalysis::analyzeDataAccess(query, params, std::move(solnRoot)); } +bool providesSort(const CanonicalQuery& query, const BSONObj& kp) { + return query.getFindCommandRequest().getSort().isPrefixOf( + kp, SimpleBSONElementComparator::kInstance); +} + StatusWith<std::unique_ptr<PlanCacheIndexTree>> QueryPlanner::cacheDataFromTaggedTree( const MatchExpression* const taggedTree, const vector<IndexEntry>& relevantIndices) { if (!taggedTree) { @@ -708,7 +661,7 @@ StatusWith<std::unique_ptr<QuerySolution>> QueryPlanner::planFromCache( } else if (SolutionCacheData::COLLSCAN_SOLN == winnerCacheData.solnType) { // The cached solution is a collection scan. We don't cache collscans // with tailable==true, hence the false below. - auto soln = buildCollscanSoln(query, false, params, winnerCacheData.wholeIXSolnDir); + auto soln = buildCollscanSoln(query, false, params); if (!soln) { return Status(ErrorCodes::NoQueryExecutionPlans, "plan cache error: collection scan soln"); @@ -730,11 +683,10 @@ StatusWith<std::unique_ptr<QuerySolution>> QueryPlanner::planFromCache( "filter"_attr = redact(clone->debugString()), "cacheData"_attr = redact(winnerCacheData.toString())); - RelevantFieldIndexMap fields; + stdx::unordered_set<string> fields; QueryPlannerIXSelect::getFields(query.root(), &fields); - // We will not cache queries with 'hint'. std::vector<IndexEntry> expandedIndexes = - QueryPlannerIXSelect::expandIndexes(fields, params.indices, false /* indexHinted */); + QueryPlannerIXSelect::expandIndexes(fields, params.indices); // Map from index name to index number. map<IndexEntry::Identifier, size_t> indexMap; @@ -785,38 +737,6 @@ StatusWith<std::unique_ptr<QuerySolution>> QueryPlanner::planFromCache( return {std::move(soln)}; } -// If no table scan option is set the planner may not return any plan containing a collection scan. -// Yet clusteredIdxScans are still allowed as they are not a full collection scan but a bounded -// collection scan. -bool noTableScan(const QueryPlannerParams& params) { - return (params.options & QueryPlannerParams::NO_TABLE_SCAN); -} - -// Used internally if the planner should also avoid retruning a plan containing a clusteredIDX scan. -bool noTableAndClusteredIDXScan(const QueryPlannerParams& params) { - return (params.options & QueryPlannerParams::STRICT_NO_TABLE_SCAN); -} - -bool isClusteredScan(QuerySolutionNode* node) { - if (node->getType() == STAGE_COLLSCAN) { - auto collectionScanSolnNode = dynamic_cast<CollectionScanNode*>(node); - return (collectionScanSolnNode->doClusteredCollectionScan()); - } - return false; -} - -// Check if this is a real coll scan or a hidden ClusteredIDX scan. -bool isColusteredIDXScanSoln(QuerySolution* collscanSoln) { - if (collscanSoln->root()->getType() == STAGE_SHARDING_FILTER) { - auto child = collscanSoln->root()->children.begin(); - return isClusteredScan(*child); - } - if (collscanSoln->root()->getType() == STAGE_COLLSCAN) { - return isClusteredScan(collscanSoln->root()); - } - return false; -} - StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( const CanonicalQuery& query, const QueryPlannerParams& params) { // It's a little silly to ask for a count and for owned data. This could indicate a bug @@ -870,6 +790,7 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( // any $natural sort to have been normalized to a $natural hint upstream. // Additionally, if the hint matches the collection's cluster key, we also output a // collscan utilizing the cluster key. + if (naturalHint) { // Perform validation specific to $natural. LOGV2_DEBUG(20969, 5, "Forcing a table scan due to hinted $natural"); @@ -929,7 +850,7 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( out.push_back(std::move(soln)); return {std::move(out)}; } - } // namespace mongo + } // Hints require us to only consider the hinted index. If index filters in the query // settings were used to override the allowed indices for planning, we should not use the @@ -967,14 +888,13 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( } // Figure out what fields we care about. - RelevantFieldIndexMap fields; + stdx::unordered_set<string> fields; QueryPlannerIXSelect::getFields(query.root(), &fields); for (auto&& field : fields) { - LOGV2_DEBUG(20970, 5, "Predicate over field", "field"_attr = field.first); + LOGV2_DEBUG(20970, 5, "Predicate over field", "field"_attr = field); } - fullIndexList = QueryPlannerIXSelect::expandIndexes( - fields, std::move(fullIndexList), !hintedIndex.isEmpty()); + fullIndexList = QueryPlannerIXSelect::expandIndexes(fields, std::move(fullIndexList)); std::vector<IndexEntry> relevantIndices; if (!hintedIndexEntry) { @@ -1337,6 +1257,37 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( } } } + + // The base index is sorted on some key, so it's possible we might want to use + // a collection scan to provide the sort requested + if (params.clusteredInfo) { + if (CollatorInterface::collatorsMatch(params.clusteredCollectionCollator, + query.getCollator())) { + auto kp = clustered_util::getSortPattern(params.clusteredInfo->getIndexSpec()); + int direction = 0; + if (providesSort(query, kp)) { + direction = 1; + } else if (providesSort(query, QueryPlannerCommon::reverseSortObj(kp))) { + direction = -1; + } + + if (direction != 0) { + auto soln = buildCollscanSoln(query, isTailable, params, direction); + if (soln) { + LOGV2_DEBUG(6082401, + 5, + "Planner: outputting soln that uses clustered index to " + "provide sort"); + SolutionCacheData* scd = new SolutionCacheData(); + scd->solnType = SolutionCacheData::COLLSCAN_SOLN; + scd->wholeIXSolnDir = direction; + + soln->cacheData.reset(scd); + out.push_back(std::move(soln)); + } + } + } + } } // If a projection exists, there may be an index that allows for a covered plan, even if @@ -1383,13 +1334,11 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( // No indexed plans? We must provide a collscan if possible or else we can't run the query. bool collScanRequired = 0 == out.size(); - if (collScanRequired && noTableAndClusteredIDXScan(params)) { + if (collScanRequired && !canTableScan) { return Status(ErrorCodes::NoQueryExecutionPlans, "No indexed plans available, and running with 'notablescan'"); } - bool clusteredCollection = params.clusteredInfo.has_value(); - // geoNear and text queries *require* an index. // Also, if a hint is specified it indicates that we MUST use it. bool possibleToCollscan = @@ -1399,53 +1348,31 @@ StatusWith<std::vector<std::unique_ptr<QuerySolution>>> QueryPlanner::plan( return Status(ErrorCodes::NoQueryExecutionPlans, "No query solutions"); } - bool isClusteredIDXScan = false; - if (possibleToCollscan && (collscanRequested || collScanRequired || clusteredCollection)) { - auto clusteredScanDirection = determineClusteredScanDirection(query, params); - auto direction = clusteredScanDirection.value_or(1); - auto [collscanSoln, collscanNode] = - buildCollscanSolnWithNode(query, isTailable, params, direction); - if (!collscanSoln && collScanRequired) { + if (possibleToCollscan && (collscanRequested || collScanRequired)) { + auto collscan = buildCollscanSoln(query, isTailable, params); + if (!collscan && collScanRequired) { return Status(ErrorCodes::NoQueryExecutionPlans, "Failed to build collection scan soln"); } - isClusteredIDXScan = isColusteredIDXScanSoln(collscanSoln.get()); - // We consider collection scan in the following cases: - // 1. collScanRequested - specifically requested by caller. - // 2. collScanRequired - there are no other possible plans, so we fallback to full scan. - // 3. collscanIsBounded - collection is clustered and clustered index is used. - // 4. clusteredScanDirection - collection is clustered and sort, provided by clustered - // index, is used - if (collscanSoln && - (collscanRequested || collScanRequired || collscanIsBounded(collscanNode) || - clusteredScanDirection)) { + if (collscan) { LOGV2_DEBUG(20984, 5, "Planner: outputting a collection scan", - "collectionScan"_attr = redact(collscanSoln->toString())); + "collectionScan"_attr = redact(collscan->toString())); SolutionCacheData* scd = new SolutionCacheData(); scd->solnType = SolutionCacheData::COLLSCAN_SOLN; - scd->wholeIXSolnDir = direction; - collscanSoln->cacheData.reset(scd); - out.push_back(std::move(collscanSoln)); + collscan->cacheData.reset(scd); + out.push_back(std::move(collscan)); } } - // Make sure to respect the notablescan option. A clustered IDX scan is allowed even under a - // NOTABLE option. Only in the case of a strict NOTABLE scan option a clustered IDX scan is not - // allowed. This option is used in mongoS for shardPruning. invariant(out.size() > 0); - if (collScanRequired && noTableScan(params) && !isClusteredIDXScan) { - return Status(ErrorCodes::NoQueryExecutionPlans, - "No indexed plans available, and running with 'notablescan'"); - } return {std::move(out)}; } /** - * The 'query' might contain parts of aggregation pipeline. For now, we plan those separately - * and later attach the agg portion of the plan to the solution(s) for the "find" part of the - * query. + * The 'query' might contain parts of aggregation pipeline. For now, we plan those separately and + * later attach the agg portion of the plan to the solution(s) for the "find" part of the query. */ std::unique_ptr<QuerySolution> QueryPlanner::extendWithAggPipeline( const CanonicalQuery& query, @@ -1625,13 +1552,13 @@ StatusWith<QueryPlanner::SubqueriesPlanningResult> QueryPlanner::planSubqueries( planningResult.branches.push_back( std::make_unique<SubqueriesPlanningResult::BranchPlanningResult>()); auto branchResult = planningResult.branches.back().get(); + auto orChild = planningResult.orExpression->getChild(i); // Turn the i-th child into its own query. - auto statusWithCQ = CanonicalQuery::makeForSubplanner(opCtx, query, i); + auto statusWithCQ = CanonicalQuery::canonicalize(opCtx, query, orChild); if (!statusWithCQ.isOK()) { str::stream ss; - ss << "Can't canonicalize subchild " - << planningResult.orExpression->getChild(i)->debugString() << " " + ss << "Can't canonicalize subchild " << orChild->debugString() << " " << statusWithCQ.getStatus().reason(); return Status(ErrorCodes::BadValue, ss); } diff --git a/src/mongo/db/query/query_planner_array_test.cpp b/src/mongo/db/query/query_planner_array_test.cpp index ff39e98c3d0..19dfc99dbcd 100644 --- a/src/mongo/db/query/query_planner_array_test.cpp +++ b/src/mongo/db/query/query_planner_array_test.cpp @@ -2110,13 +2110,13 @@ TEST_F(QueryPlannerTest, CanHoistNegatedPredFromElemMatchIntoSiblingOrWithMultik "{fetch: {filter: {arr: {$elemMatch: {a: {$ne: 1}, b: {$in: [2, 3]}}}}," "node: {" " or: {nodes: [" - " {fetch: {filter: {'arr.a': {$ne: 1}}," + " {fetch: {filter: {a: {$ne: 1}}," " node: {ixscan: {pattern: {'arr.a': 1, 'arr.b': 1, c: 1, d: 1}," " bounds: {'arr.a': [['MinKey', 1, true, false], [1, 'MaxKey', false, true]]," " 'arr.b': [[2, 2, true, true], [3, 3, true, true]]," " c: [[4, 4, true, true]]," " d: [[5, 5, true, true]]}}}}}," - " {fetch: {filter: {'arr.a': {$ne: 1}}," + " {fetch: {filter: {a: {$ne: 1}}," " node: {ixscan: {pattern: {'arr.a': 1, 'arr.b': 1, c: 1, d: 1}," " bounds: {'arr.a': [['MinKey', 1, true, false],[1, 'MaxKey', false, true]]," " 'arr.b': [[2, 2, true, true], [3, 3, true, true]]," diff --git a/src/mongo/db/query/query_planner_common.h b/src/mongo/db/query/query_planner_common.h index 97e94bb0a69..6d441155b54 100644 --- a/src/mongo/db/query/query_planner_common.h +++ b/src/mongo/db/query/query_planner_common.h @@ -65,20 +65,6 @@ public: } /** - * Returns a count of 'type' nodes in expression tree. - */ - static size_t countNodes(const MatchExpression* root, MatchExpression::MatchType type) { - size_t sum = 0; - if (type == root->matchType()) { - sum = 1; - } - for (size_t i = 0; i < root->numChildren(); ++i) { - sum += countNodes(root->getChild(i), type); - } - return sum; - } - - /** * Assumes the provided BSONObj is of the form {field1: -+1, ..., field2: -+1} * Returns a BSONObj with the values negated. */ diff --git a/src/mongo/db/query/query_planner_index_test.cpp b/src/mongo/db/query/query_planner_index_test.cpp index 24631b9091e..045fa35dbe1 100644 --- a/src/mongo/db/query/query_planner_index_test.cpp +++ b/src/mongo/db/query/query_planner_index_test.cpp @@ -198,20 +198,26 @@ TEST_F(QueryPlannerTest, SparseIndexForQuery) { "{filter: null, pattern: {a: 1}}}}}"); } -TEST_F(QueryPlannerTest, ExprEqCannotUseSparseIndex) { +TEST_F(QueryPlannerTest, ExprEqCanUseSparseIndex) { params.options &= ~QueryPlannerParams::INCLUDE_COLLSCAN; addIndex(fromjson("{a: 1}"), false, true); runQuery(fromjson("{a: {$_internalExprEq: 1}}")); - assertHasOnlyCollscan(); + assertNumSolutions(1U); + assertSolutionExists( + "{fetch: {filter: null, node: {ixscan: " + "{filter: null, pattern: {a: 1}, bounds: {a: [[1,1,true,true]]}}}}}"); } -TEST_F(QueryPlannerTest, ExprEqCannotUseSparseIndexForEqualityToNull) { +TEST_F(QueryPlannerTest, ExprEqCanUseSparseIndexForEqualityToNull) { params.options &= ~QueryPlannerParams::INCLUDE_COLLSCAN; addIndex(fromjson("{a: 1}"), false, true); runQuery(fromjson("{a: {$_internalExprEq: null}}")); - assertHasOnlyCollscan(); + assertNumSolutions(1U); + assertSolutionExists( + "{fetch: {filter: {a: {$_internalExprEq: null}}, node: {ixscan: {filter: null, pattern: " + "{a: 1}, bounds: {a: [[undefined,undefined,true,true], [null,null,true,true]]}}}}}"); } TEST_F(QueryPlannerTest, NegationCannotUseSparseIndex) { diff --git a/src/mongo/db/query/query_planner_params.h b/src/mongo/db/query/query_planner_params.h index ab07388710f..c8542cda90e 100644 --- a/src/mongo/db/query/query_planner_params.h +++ b/src/mongo/db/query/query_planner_params.h @@ -153,11 +153,6 @@ struct QueryPlannerParams { // Ensure that any plan generated returns data that is "owned." That is, all BSONObjs are // in an "owned" state and are not pointing to data that belongs to the storage engine. RETURN_OWNED_DATA = 1 << 12, - - // This is an extension to the NO_TABLE_SCAN parameter. This more stricter option will also - // avoid a CLUSTEREDIDX_SCAN which comes built into a collection scan when the collection is - // clustered. - STRICT_NO_TABLE_SCAN = 1 << 13, }; // See Options enum above. diff --git a/src/mongo/db/query/query_planner_test_lib.cpp b/src/mongo/db/query/query_planner_test_lib.cpp index 849ce6fb6e8..bec219226b5 100644 --- a/src/mongo/db/query/query_planner_test_lib.cpp +++ b/src/mongo/db/query/query_planner_test_lib.cpp @@ -1234,10 +1234,7 @@ Status QueryPlannerTestLib::solutionMatches(const BSONObj& testSoln, } BSONObjBuilder bob; - actualGroupNode->groupByExpression - ->serialize(SerializationOptions{ - boost::make_optional(ExplainOptions::Verbosity::kQueryPlanner)}) - .addToBsonObj(&bob, "_id"); + actualGroupNode->groupByExpression->serialize(true).addToBsonObj(&bob, "_id"); auto actualGroupByObj = bob.done(); if (!SimpleBSONObjComparator::kInstance.evaluate(actualGroupByObj == expectedGroupByElem.Obj())) { @@ -1250,10 +1247,7 @@ Status QueryPlannerTestLib::solutionMatches(const BSONObj& testSoln, BSONArrayBuilder actualAccs; for (auto& acc : actualGroupNode->accumulators) { BSONObjBuilder bob; - acc.expr.argument - ->serialize(SerializationOptions{ - boost::make_optional(ExplainOptions::Verbosity::kQueryPlanner)}) - .addToBsonObj(&bob, acc.expr.name); + acc.expr.argument->serialize(true).addToBsonObj(&bob, acc.expr.name); actualAccs.append(BSON(acc.fieldName << bob.done())); } auto expectedAccsObj = expectedGroupObj["accs"].Obj(); diff --git a/src/mongo/db/query/query_planner_tree_test.cpp b/src/mongo/db/query/query_planner_tree_test.cpp index 5b7055dd720..9d403989792 100644 --- a/src/mongo/db/query/query_planner_tree_test.cpp +++ b/src/mongo/db/query/query_planner_tree_test.cpp @@ -32,7 +32,6 @@ #include "mongo/db/query/collation/collator_interface_mock.h" #include "mongo/db/query/query_planner.h" #include "mongo/db/query/query_planner_test_fixture.h" -#include "mongo/idl/server_parameter_test_util.h" #include "mongo/unittest/unittest.h" namespace mongo { @@ -2465,32 +2464,6 @@ TEST_F(QueryPlannerTest, LockstepOrEnumerationSanityCheckTwoChildrenTwoIndexesEa "{ixscan: {pattern: {a: 1, c: 1}}}}}}}"); } -TEST_F(QueryPlannerTest, TotalPossibleLockstepOrEnumerationReachesTheOrLimit) { - params.options = - QueryPlannerParams::NO_TABLE_SCAN | QueryPlannerParams::ENUMERATE_OR_CHILDREN_LOCKSTEP; - addIndex(BSON("a" << 1 << "b" << 1)); - addIndex(BSON("a" << 1 << "c" << 1)); - - BSONArrayBuilder orBuilder; - // This max number has a value of 65 in order to potentillay triger any overflow of the possible - // enumeration count, because each predicate in $or has two possible indexes, allowing for 2^65 - // possible enumerations. - const int maxPredicates = 65; - for (int i = 0; i < maxPredicates; i++) { - orBuilder.append(BSON("b" << i << "c" << i)); - } - - auto cmd = BSON("find" - << "testns" - << "filter" << BSON("a" << 1 << "$or" << orBuilder.arr())); - - // Ensure that the query runs fine. - runQueryAsCommand(cmd); - - // internalQueryMaxOrSolutions.load() + 2. - assertNumSolutions(12U); -} - // Test that we enumerate the expected plans with the special parameter set. In this test we have // two branches of an $or, each with one possible indexed solution. TEST_F(QueryPlannerTest, LockstepOrEnumerationSanityCheckTwoChildrenOneIndexEach) { @@ -2847,89 +2820,6 @@ TEST_F(QueryPlannerTest, LockstepOrEnumerationApplysToEachOrInTree) { "]}}"); } -// This test was designed to reproduce SERVER-83091, a case in which an implementation error in the -// lockstep $or enumeration algorithm could result in an infinite loop. This could happen only if -// there were nested $or nodes and the inner $or hit the maximum number of plans that it is willing -// to generate. -TEST_F(QueryPlannerTest, LockstepOrEnumerationWithNestedOrWhereInnerOrHitsEnumerationLimit) { - // Disable match expression optimixation, since when enabled it will collapse nested $or nodes - // into a single $or. - FailPointEnableBlock failPoint("disableMatchExpressionOptimization"); - - // The repro depends on the inner $or hitting its enumeration limit. The original problem from - // SERVER-83091 can be reproduced with a simpler query if we lower the limit on the number of - // plans that the 'PlanEnumerator' is allowed to generate for any $or node. - RAIIServerParameterControllerForTest maxOrPlansController( - "internalQueryEnumerationMaxOrSolutions", 3); - - params.options = - QueryPlannerParams::NO_TABLE_SCAN | QueryPlannerParams::ENUMERATE_OR_CHILDREN_LOCKSTEP; - addIndex(BSON("a" << 1)); - addIndex(BSON("b" << 1)); - addIndex(BSON("c" << 1)); - - runQueryAsCommand(fromjson(R"( - {find: 'testns', filter: { - $or: [ - {$or: [ - {a: 1, b: 2}, - {a: 3} - ]}, - {c: 4} - ] - }})")); - - // There are two plans, the only difference between the two being whether the nested $and - // {a: 1, b: 2} uses the index on "a" or the index on "b". - assertNumSolutions(2U); - - // Plan using the {a: 1} index for the innermost conjunction. - assertSolutionExists(R"( - { - fetch: { - node: { - or: { - nodes: [ - { - or: { - nodes: [ - {fetch: {filter: {b: 2}, node: {ixscan: {pattern: {a: 1}}}}}, - {ixscan: {pattern: {a: 1}}} - ] - } - }, - {ixscan: {pattern: {c: 1}}} - ] - } - } - } - } - )"); - - // Alternative plan using the {b: 1} index for the innermost conjunction. - assertSolutionExists(R"( - { - fetch: { - node: { - or: { - nodes: [ - { - or: { - nodes: [ - {fetch: {filter: {a: 1}, node: {ixscan: {pattern: {b: 1}}}}}, - {ixscan: {pattern: {a: 1}}} - ] - } - }, - {ixscan: {pattern: {c: 1}}} - ] - } - } - } - } - )"); -} - TEST_F(QueryPlannerTest, NoOrSolutionsIfMaxOrSolutionsIsZero) { auto defaultMaxOr = internalQueryEnumerationMaxOrSolutions.load(); ON_BLOCK_EXIT([&] { internalQueryEnumerationMaxOrSolutions.store(defaultMaxOr); }); diff --git a/src/mongo/db/query/query_planner_wildcard_index_test.cpp b/src/mongo/db/query/query_planner_wildcard_index_test.cpp index eca110ffac0..cd943126a17 100644 --- a/src/mongo/db/query/query_planner_wildcard_index_test.cpp +++ b/src/mongo/db/query/query_planner_wildcard_index_test.cpp @@ -56,7 +56,7 @@ protected: } void addWildcardIndex(BSONObj keyPattern, - const OrderedPathSet& multikeyPathSet = {}, + const std::set<std::string>& multikeyPathSet = {}, BSONObj wildcardProjection = BSONObj{}, MatchExpression* partialFilterExpr = nullptr, CollatorInterface* collator = nullptr, @@ -418,18 +418,25 @@ TEST_F(QueryPlannerWildcardTest, EqualityIndexScanOverNestedField) { "bounds: {'$_path': [['a.b','a.b',true,true]], 'a.b': [[5,5,true,true]]}}}}}"); } -TEST_F(QueryPlannerWildcardTest, ExprEqCannotUseIndex) { +TEST_F(QueryPlannerWildcardTest, ExprEqCanUseIndex) { addWildcardIndex(BSON("$**" << 1)); runQuery(fromjson("{a: {$_internalExprEq: 1}}")); - assertHasOnlyCollscan(); + assertNumSolutions(1U); + assertSolutionExists( + "{fetch: {filter: null, node: {ixscan: {pattern: {'$_path': 1, a: 1}," + "bounds: {'$_path': [['a','a',true,true]], a: [[1,1,true,true]]}}}}}"); } -TEST_F(QueryPlannerWildcardTest, ExprEqCannotUseSparseIndexForEqualityToNull) { +TEST_F(QueryPlannerWildcardTest, ExprEqCanUseSparseIndexForEqualityToNull) { addWildcardIndex(BSON("$**" << 1)); runQuery(fromjson("{a: {$_internalExprEq: null}}")); - assertHasOnlyCollscan(); + assertNumSolutions(1U); + assertSolutionExists( + "{fetch: {filter: {a: {$_internalExprEq: null}}, node: {ixscan: {pattern: {'$_path': 1, a: " + "1}, bounds: {'$_path': [['a','a',true,true]], a: [[undefined,undefined,true,true], " + "[null,null,true,true]]}}}}}"); } TEST_F(QueryPlannerWildcardTest, PrefixRegex) { diff --git a/src/mongo/db/query/query_request_helper.cpp b/src/mongo/db/query/query_request_helper.cpp index b713b9d8000..410c05fcaf0 100644 --- a/src/mongo/db/query/query_request_helper.cpp +++ b/src/mongo/db/query/query_request_helper.cpp @@ -85,35 +85,6 @@ Status validateGetMoreCollectionName(StringData collectionName) { return Status::OK(); } -Status validateResumeAfter(const mongo::BSONObj& resumeAfter, bool isClusteredCollection) { - if (resumeAfter.isEmpty()) { - return Status::OK(); - } - - BSONType recordIdType = resumeAfter["$recordId"].type(); - if (resumeAfter.nFields() != 1 || - (recordIdType != BSONType::NumberLong && recordIdType != BSONType::BinData && - recordIdType != BSONType::jstNULL)) { - return Status(ErrorCodes::BadValue, - "Malformed resume token: the '_resumeAfter' object must contain" - " exactly one field named '$recordId', of type NumberLong, BinData " - "or jstNULL."); - } - - // Clustered collections can only have accept '$_resumeAfter' parameter of type - // BinData. Non clustered collections should only accept '$_resumeAfter' of type - // Long. - if ((isClusteredCollection && recordIdType == BSONType::NumberLong) || - (!isClusteredCollection && recordIdType == BSONType::BinData)) { - return Status(ErrorCodes::Error(7738600), - "The '$_resumeAfter parameter must match collection type. Clustered " - "collections only have BinData recordIds, and all other collections" - "have Long recordId."); - } - - return Status::OK(); -} - Status validateFindCommandRequest(const FindCommandRequest& findCommand) { // Min and Max objects must have the same fields. if (!findCommand.getMin().isEmpty() && !findCommand.getMax().isEmpty()) { @@ -156,8 +127,17 @@ Status validateFindCommandRequest(const FindCommandRequest& findCommand) { return Status(ErrorCodes::BadValue, "sort must be unset or {$natural:1} if 'requestResumeToken' is enabled"); } - // The $_resumeAfter parameter is checked in 'validateResumeAfter()'. - + if (!findCommand.getResumeAfter().isEmpty()) { + if (findCommand.getResumeAfter().nFields() != 1 || + (findCommand.getResumeAfter()["$recordId"].type() != BSONType::NumberLong && + findCommand.getResumeAfter()["$recordId"].type() != BSONType::BinData && + findCommand.getResumeAfter()["$recordId"].type() != BSONType::jstNULL)) { + return Status(ErrorCodes::BadValue, + "Malformed resume token: the '_resumeAfter' object must contain" + " exactly one field named '$recordId', of type NumberLong, BinData " + "or jstNULL."); + } + } } else if (!findCommand.getResumeAfter().isEmpty()) { return Status(ErrorCodes::BadValue, "'requestResumeToken' must be true if 'resumeAfter' is" diff --git a/src/mongo/db/query/query_request_helper.h b/src/mongo/db/query/query_request_helper.h index c0d8968f563..4d3ec6143c8 100644 --- a/src/mongo/db/query/query_request_helper.h +++ b/src/mongo/db/query/query_request_helper.h @@ -63,12 +63,6 @@ static constexpr auto kNaturalSortField = "$natural"; Status validateGetMoreCollectionName(StringData collectionName); /** - * Returns a non-OK status if '$_resumeAfter' is set to an unexpected value, or the wrong type - * determined by the collection type. - */ -Status validateResumeAfter(const mongo::BSONObj& resumeAfter, bool isClusteredCollection); - -/** * Returns a non-OK status if any property of the QR has a bad value (e.g. a negative skip * value) or if there is a bad combination of options (e.g. awaitData is illegal without * tailable). diff --git a/src/mongo/db/query/query_request_test.cpp b/src/mongo/db/query/query_request_test.cpp index 52c6dd4aca7..80ed0325802 100644 --- a/src/mongo/db/query/query_request_test.cpp +++ b/src/mongo/db/query/query_request_test.cpp @@ -36,7 +36,6 @@ #include "mongo/base/error_codes.h" #include "mongo/db/catalog/collection_catalog.h" #include "mongo/db/catalog/collection_mock.h" -#include "mongo/db/cursor_id.h" #include "mongo/db/dbmessage.h" #include "mongo/db/json.h" #include "mongo/db/namespace_string.h" @@ -279,13 +278,10 @@ TEST(QueryRequestTest, InvalidResumeAfterWrongRecordIdType) { findCommand.setRequestResumeToken(true); // Hint must be explicitly set for the query request to validate. findCommand.setHint(fromjson("{$natural: 1}")); - ASSERT_NOT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); + ASSERT_NOT_OK(query_request_helper::validateFindCommandRequest(findCommand)); resumeAfter = BSON("$recordId" << 1LL); findCommand.setResumeAfter(resumeAfter); ASSERT_OK(query_request_helper::validateFindCommandRequest(findCommand)); - ASSERT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); } TEST(QueryRequestTest, InvalidResumeAfterExtraField) { @@ -295,8 +291,7 @@ TEST(QueryRequestTest, InvalidResumeAfterExtraField) { findCommand.setRequestResumeToken(true); // Hint must be explicitly set for the query request to validate. findCommand.setHint(fromjson("{$natural: 1}")); - ASSERT_NOT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); + ASSERT_NOT_OK(query_request_helper::validateFindCommandRequest(findCommand)); } TEST(QueryRequestTest, ResumeAfterWithHint) { @@ -319,8 +314,6 @@ TEST(QueryRequestTest, ResumeAfterWithSort) { // Hint must be explicitly set for the query request to validate. findCommand.setHint(fromjson("{$natural: 1}")); ASSERT_OK(query_request_helper::validateFindCommandRequest(findCommand)); - ASSERT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); findCommand.setSort(fromjson("{a: 1}")); ASSERT_NOT_OK(query_request_helper::validateFindCommandRequest(findCommand)); findCommand.setSort(fromjson("{$natural: 1}")); @@ -336,8 +329,6 @@ TEST(QueryRequestTest, ResumeNoSpecifiedRequestResumeToken) { ASSERT_NOT_OK(query_request_helper::validateFindCommandRequest(findCommand)); findCommand.setRequestResumeToken(true); ASSERT_OK(query_request_helper::validateFindCommandRequest(findCommand)); - ASSERT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); } TEST(QueryRequestTest, ExplicitEmptyResumeAfter) { @@ -349,8 +340,6 @@ TEST(QueryRequestTest, ExplicitEmptyResumeAfter) { ASSERT_OK(query_request_helper::validateFindCommandRequest(findCommand)); findCommand.setRequestResumeToken(true); ASSERT_OK(query_request_helper::validateFindCommandRequest(findCommand)); - ASSERT_OK(query_request_helper::validateResumeAfter(findCommand.getResumeAfter(), - false /* isClusteredCollection */)); } // diff --git a/src/mongo/db/query/query_shape.cpp b/src/mongo/db/query/query_shape.cpp deleted file mode 100644 index 02d4c97d25f..00000000000 --- a/src/mongo/db/query/query_shape.cpp +++ /dev/null @@ -1,292 +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 "mongo/db/query/query_shape.h" - -#include "mongo/base/status.h" -#include "mongo/db/query/find_command_gen.h" -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/query_request_helper.h" -#include "mongo/db/query/query_shape_gen.h" -#include "mongo/db/query/query_stats/query_stats.h" -#include "mongo/db/query/shape_helpers.h" -#include "mongo/db/query/sort_pattern.h" - -namespace mongo::query_shape { - -BSONObj debugPredicateShape(const MatchExpression* predicate) { - SerializationOptions opts; - opts.literalPolicy = LiteralSerializationPolicy::kToDebugTypeString; - return predicate->serialize(opts); -} -BSONObj representativePredicateShape(const MatchExpression* predicate) { - SerializationOptions opts; - opts.literalPolicy = LiteralSerializationPolicy::kToRepresentativeParseableValue; - return predicate->serialize(opts); -} - -BSONObj debugPredicateShape(const MatchExpression* predicate, - std::function<std::string(StringData)> transformIdentifiersCallback) { - SerializationOptions opts; - opts.literalPolicy = LiteralSerializationPolicy::kToDebugTypeString; - opts.transformIdentifiersCallback = transformIdentifiersCallback; - opts.transformIdentifiers = true; - return predicate->serialize(opts); -} - -BSONObj representativePredicateShape( - const MatchExpression* predicate, - std::function<std::string(StringData)> transformIdentifiersCallback) { - SerializationOptions opts; - opts.literalPolicy = LiteralSerializationPolicy::kToRepresentativeParseableValue; - opts.transformIdentifiersCallback = transformIdentifiersCallback; - opts.transformIdentifiers = true; - return predicate->serialize(opts); -} - -BSONObj extractSortShape(const BSONObj& sortSpec, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts) { - if (sortSpec.isEmpty()) { - return sortSpec; - } - auto natural = sortSpec[query_request_helper::kNaturalSortField]; - - if (!natural) { - return SortPattern{sortSpec, expCtx} - .serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts) - .toBson(); - } - // This '$natural' will fail to parse as a valid SortPattern since it is not a valid field - // path - it is usually considered and converted into a hint. For the query shape, we'll - // keep it unmodified. - BSONObjBuilder bob; - for (auto&& elem : sortSpec) { - if (elem.isABSONObj()) { - // We expect this won't work or parse on the main command path, but for shapification we - // don't really care, just treat it as a literal and don't bother parsing. - opts.appendLiteral( - &bob, opts.serializeFieldPathFromString(elem.fieldNameStringData()), elem); - } else if (elem.fieldNameStringData() == natural.fieldNameStringData()) { - bob.append(elem); - } else { - bob.appendAs(elem, opts.serializeFieldPathFromString(elem.fieldNameStringData())); - } - } - return bob.obj(); -} - -void addShapeLiterals(BSONObjBuilder* bob, - const FindCommandRequest& findCommand, - const SerializationOptions& opts) { - if (auto limit = findCommand.getLimit()) { - opts.appendLiteral( - bob, FindCommandRequest::kLimitFieldName, static_cast<long long>(*limit)); - } - if (auto skip = findCommand.getSkip()) { - opts.appendLiteral(bob, FindCommandRequest::kSkipFieldName, static_cast<long long>(*skip)); - } -} - -static std::vector< - std::pair<StringData, std::function<const OptionalBool(const FindCommandRequest&)>>> - boolArgMap = { - {FindCommandRequest::kSingleBatchFieldName, &FindCommandRequest::getSingleBatch}, - {FindCommandRequest::kAllowDiskUseFieldName, &FindCommandRequest::getAllowDiskUse}, - {FindCommandRequest::kReturnKeyFieldName, &FindCommandRequest::getReturnKey}, - {FindCommandRequest::kShowRecordIdFieldName, &FindCommandRequest::getShowRecordId}, - {FindCommandRequest::kTailableFieldName, &FindCommandRequest::getTailable}, - {FindCommandRequest::kAwaitDataFieldName, &FindCommandRequest::getAwaitData}, -}; -std::vector<std::pair<StringData, std::function<const BSONObj(const FindCommandRequest&)>>> - objArgMap = { - {FindCommandRequest::kCollationFieldName, &FindCommandRequest::getCollation}, - -}; - -void addRemainingFindCommandFields(BSONObjBuilder* bob, - const FindCommandRequest& findCommand, - const SerializationOptions& opts) { - for (auto [fieldName, getterFunction] : boolArgMap) { - auto optBool = getterFunction(findCommand); - optBool.serializeToBSON(fieldName, bob); - } - - if (auto optOplogReplay = findCommand.getOplogReplay()) { - if (optOplogReplay.has_value()) { - opts.appendLiteral( - bob, FindCommandRequest::kOplogReplayFieldName, optOplogReplay.value_or(false)); - } - } - - auto collation = findCommand.getCollation(); - if (!collation.isEmpty()) { - bob->append(FindCommandRequest::kCollationFieldName, collation); - } -} - - -/** - * In a let specification all field names are variable names, and all values are either - * expressions or constants. - */ -BSONObj extractLetSpecShape(BSONObj letSpec, - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx) { - - BSONObjBuilder bob; - for (BSONElement elem : letSpec) { - auto expr = Expression::parseOperand(expCtx.get(), elem, expCtx->variablesParseState); - auto redactedValue = expr->serialize(opts); - // Note that this will throw on deeply nested let variables. - redactedValue.addToBsonObj(&bob, opts.serializeFieldPathFromString(elem.fieldName())); - } - return bob.obj(); -} - -void appendCmdNs(BSONObjBuilder& bob, - const NamespaceString& nss, - const SerializationOptions& opts) { - BSONObjBuilder nsObj = bob.subobjStart("cmdNs"); - shape_helpers::appendNamespaceShape(nsObj, nss, opts); - nsObj.doneFast(); -} - -BSONObj extractQueryShape(const ParsedFindCommand& findRequest, - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx) { - const auto& findCmd = *findRequest.findCommandRequest; - BSONObjBuilder bob; - // Serialize the namespace as part of the query shape. - { - auto ns = findCmd.getNamespaceOrUUID(); - if (ns.nss().has_value()) { - appendCmdNs(bob, *ns.nss(), opts); - } else { - BSONObjBuilder cmdNs = bob.subobjStart("cmdNs"); - cmdNs.append("uuid", opts.serializeIdentifier(ns.uuid()->toString())); - cmdNs.append("db", opts.serializeIdentifier(ns.db())); - cmdNs.doneFast(); - } - } - - bob.append("command", "find"); - std::unique_ptr<MatchExpression> filterExpr; - // Filter. - bob.append(FindCommandRequest::kFilterFieldName, findRequest.filter->serialize(opts)); - // Let Spec. - if (auto letSpec = findCmd.getLet()) { - auto redactedObj = extractLetSpecShape(letSpec.get(), opts, expCtx); - auto ownedObj = redactedObj.getOwned(); - bob.append(FindCommandRequest::kLetFieldName, std::move(ownedObj)); - } - - if (findRequest.proj) { - bob.append(FindCommandRequest::kProjectionFieldName, - projection_ast::serialize(*findRequest.proj->root(), opts)); - } - - if (!findCmd.getMax().isEmpty()) { - bob.append(FindCommandRequest::kMaxFieldName, - shape_helpers::extractMinOrMaxShape(findCmd.getMax(), opts)); - } - if (!findCmd.getMin().isEmpty()) { - bob.append(FindCommandRequest::kMinFieldName, - shape_helpers::extractMinOrMaxShape(findCmd.getMin(), opts)); - } - - // Sort. - if (findRequest.sort) { - bob.append( - FindCommandRequest::kSortFieldName, - findRequest.sort - ->serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts) - .toBson()); - } - - // Fields for literal redaction. Adds limit and skip. - addShapeLiterals(&bob, findCmd, opts); - - // Add the fields that require no redaction. - addRemainingFindCommandFields(&bob, findCmd, opts); - - return bob.obj(); -} - -BSONObj extractQueryShape(const AggregateCommandRequest& aggregateCommand, - const Pipeline& pipeline, - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const NamespaceString& nss) { - BSONObjBuilder bob; - - // namespace - appendCmdNs(bob, nss, opts); - bob.append("command", "aggregate"); - - // pipeline - { - BSONArrayBuilder pipelineBab( - bob.subarrayStart(AggregateCommandRequest::kPipelineFieldName)); - auto serializedPipeline = pipeline.serializeToBson(opts); - for (const auto& stage : serializedPipeline) { - pipelineBab.append(stage); - } - pipelineBab.doneFast(); - } - - // explain - if (aggregateCommand.getExplain().has_value()) { - bob.append(AggregateCommandRequest::kExplainFieldName, true); - } - - // allowDiskUse - if (auto param = aggregateCommand.getAllowDiskUse(); param.has_value()) { - bob.append(AggregateCommandRequest::kAllowDiskUseFieldName, param.value_or(false)); - } - - // collation - if (auto param = aggregateCommand.getCollation()) { - bob.append(AggregateCommandRequest::kCollationFieldName, param.get()); - } - - // let - if (auto letSpec = aggregateCommand.getLet()) { - auto redactedObj = extractLetSpecShape(letSpec.get(), opts, expCtx); - auto ownedObj = redactedObj.getOwned(); - bob.append(FindCommandRequest::kLetFieldName, std::move(ownedObj)); - } - return bob.obj(); -} - -QueryShapeHash hash(const BSONObj& queryShape) { - return QueryShapeHash::computeHash(reinterpret_cast<const uint8_t*>(queryShape.objdata()), - queryShape.objsize()); -} -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/README.md b/src/mongo/db/query/query_shape/README.md deleted file mode 100644 index b3c02d28e69..00000000000 --- a/src/mongo/db/query/query_shape/README.md +++ /dev/null @@ -1,69 +0,0 @@ -# Query Shape -A query shape is a transformed version of a command with literal values replaced by a "canonical" -BSON Type placeholder. Hence, different instances of a command would be considered to have the same -query shape if they are identical once their literal values are abstracted. - -For example, these two queries would have the same shape: -```js -db.example.findOne({x: 24}); -db.example.findOne({x: 53}); -``` -While these queries would each have a distinct shape: -```js -db.example.findOne({x: 53, y: 1}); -db.example.findOne({x: 53}); -db.example.findOne({x: "string"}); -``` -While different literal _values_ result in the same shape (matching `x` for 23 vs 53), different -BSON _types_ of the literal are considered distinct shapes (matching `x` for 53 vs "string"). - -The concept of a query shape exists not just for the find command, but for many of the CRUD commands -and aggregate. It also includes most (but not all) components of these commands, not just the query -predicate (MatchExpresssion). In these ways, "query" is meant more generally. While some components -included in the query shape are shared across the different types of commands (e.g., the "hint" -field), some are unique. For example, a find command would include a `filter` while an aggregate -command would have a `pipeline`. - -You can see which components are considered part of the query shape or not for each specific shape -type in their respective "shape component" classes, whose purpose is to determine which components -are relevant and should be included for determining the shape for specific type of command. The -structure is as follows: -- [`CmdSpecificShapeComponents`](query_shape.h#L65) - - [`LetShapeComponent`](cmd_with_let_shape.h#L48) - - [`AggCmdShapeComponents`](agg_cmd_shape.h#L82) - - [`FindCmdShapeComponents`](find_cmd_shape.h#L48) - -See more information for the different shapes in their respective classes, structured as follows: -- [`Shape`](query_shape.h) - - [`CmdWithLetShape`](cmd_with_let_shape.h) - - [`AggCmdShape`](agg_cmd_shape.h) - - [`FindCmdShape`](find_cmd_shape.h) - -## Serialization Options -`SerializationOptions` describes the way we serialize literal values. - -There are 3 different serialization options: -- `kUnchanged`: literals are serialized unmodified - - `{x: 5, y: "hello"}` -> `{x: 5, y: "hello"}` -- `kToDebugTypeString`: human readable format, type string of the literal is serialized - - `{x: 5, y: "hello"}` -> `{x: "?number", y: "?string"}` -- `kToRepresentativeParseableValue`: literal serialized to one canonical value for given type, which - must be parseable - - `{x: 5, y: "hello"}` -> `{x: 1, y: "?"}` - - An example of a query which is serialized differently due to the parseable requirement is `{x: - {$regex: "^p.*"}}`. If we serialized the pattern as if it were a normal string we would end up - with `{x: {$regex: "?"}}` however `"?"` is not a valid regex pattern, so this would fail - parsing. Instead we will serialize it this way to maintain parseability, `{x: {$regex: - "\\?"}}`, since `"\\?"` is valid regex. - -See [serialization_options.h](serialization_options.h) for more details. - -When we compute the [query shape hash](query_shape.cpp#L99-107), we use the -`kToRepresentativeParseableValue`, since all literals of the same type will become the same value. -This allows us to group together queries that have the same structure but different literal values -into the same shape, since they will result in the same hash. The term we use to refer to this is -"shapify", as we simplify the queries into their query shape. - -When shapifying, we try to get as close as possible to the original user input, but there are some -stages like `$jsonSchema` and `$setWindowFields` that output "internal" stages that are already -transformed from user input. diff --git a/src/mongo/db/query/query_shape/SConscript b/src/mongo/db/query/query_shape/SConscript deleted file mode 100644 index d4bddba4934..00000000000 --- a/src/mongo/db/query/query_shape/SConscript +++ /dev/null @@ -1,42 +0,0 @@ -# -*- mode: python -*- - -Import([ - "env", - "get_option", -]) - -env = env.Clone() - -env.Library( - target='query_shape', source=['query_shape.cpp', 'shape_helpers.cpp'], LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/db/exec/document_value/document_value', - '$BUILD_DIR/mongo/db/pipeline/field_path', - 'query_shape_common', - ], LIBDEPS_PRIVATE=[ - ]) - -env.Library( - target='query_shape_common', source=[ - 'query_shape.idl', - 'serialization_options.cpp', - ], LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/db/exec/document_value/document_value', - '$BUILD_DIR/mongo/db/pipeline/field_path', - ], LIBDEPS_PRIVATE=[ - ]) - -env.CppUnitTest( - target="db_query_query_shape_test", - source=[ - "query_shape_test.cpp", - "query_shape_test.idl", - ], - LIBDEPS=[ - "$BUILD_DIR/mongo/db/auth/authmocks", - "$BUILD_DIR/mongo/db/query/query_test_service_context", - "$BUILD_DIR/mongo/db/service_context_d_test_fixture", - "query_shape", - ], -) diff --git a/src/mongo/db/query/query_shape/agg_cmd_shape.cpp b/src/mongo/db/query/query_shape/agg_cmd_shape.cpp deleted file mode 100644 index e997150ecc6..00000000000 --- a/src/mongo/db/query/query_shape/agg_cmd_shape.cpp +++ /dev/null @@ -1,125 +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 "mongo/db/query/query_shape/agg_cmd_shape.h" - -#include "mongo/db/query/query_shape/shape_helpers.h" - -namespace mongo::query_shape { - -AggCmdShapeComponents::AggCmdShapeComponents( - const AggregateCommandRequest& aggRequest, - stdx::unordered_set<NamespaceString> involvedNamespaces_, - std::vector<BSONObj> pipeline) - : allowDiskUse(aggRequest.getAllowDiskUse()), - involvedNamespaces(std::move(involvedNamespaces_)), - representativePipeline(std::move(pipeline)) {} - -AggCmdShapeComponents::AggCmdShapeComponents( - OptionalBool allowDiskUse, - stdx::unordered_set<NamespaceString> involvedNamespaces_, - std::vector<BSONObj> pipeline) - : allowDiskUse(allowDiskUse), - involvedNamespaces(std::move(involvedNamespaces_)), - representativePipeline(std::move(pipeline)) {} - -void AggCmdShapeComponents::HashValue(absl::HashState state) const { - state = absl::HashState::combine(std::move(state), allowDiskUse); - for (auto&& shapifiedStage : representativePipeline) { - state = absl::HashState::combine(std::move(state), simpleHash(shapifiedStage)); - } -} - -void AggCmdShape::appendLetCmdSpecificShapeComponents( - BSONObjBuilder& bob, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts) const { - tassert(7633000, - "We don't support serializing to the unmodified shape here, since we have already " - "shapified and stored the representative query - we've lost the original literals", - opts.literalPolicy != LiteralSerializationPolicy::kUnchanged); - - if (opts == SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - // We have this copy stored already! - return _components.appendTo(bob); - } else { - // The cached pipeline shape doesn't match the requested options, so we have to - // re-parse the pipeline from the initial request. - expCtx->inMongos = _inMongos; - expCtx->addResolvedNamespaces(_components.involvedNamespaces); - auto reparsed = Pipeline::parse(_components.representativePipeline, expCtx); - auto serializedPipeline = reparsed->serializeToBson(opts); - AggCmdShapeComponents{ - _components.allowDiskUse, _components.involvedNamespaces, serializedPipeline} - .appendTo(bob); - } -} - -void AggCmdShapeComponents::appendTo(BSONObjBuilder& bob) const { - bob.append("command", "aggregate"); - - // pipeline - bob.append(AggregateCommandRequest::kPipelineFieldName, representativePipeline); - - // allowDiskUse - if (allowDiskUse.has_value()) { - bob.append(AggregateCommandRequest::kAllowDiskUseFieldName, bool(allowDiskUse)); - } -} - -// As part of the size, we must track the allocation of elements in the representative -// pipeline, as well as the elements in the unordered set of involved namespaces. -size_t AggCmdShapeComponents::size() const { - return sizeof(AggCmdShapeComponents) + shape_helpers::containerSize(representativePipeline) + - shape_helpers::containerSize(involvedNamespaces); -} - -AggCmdShape::AggCmdShape(const AggregateCommandRequest& aggregateCommand, - NamespaceString origNss, - stdx::unordered_set<NamespaceString> involvedNamespaces_, - const Pipeline& pipeline, - const boost::intrusive_ptr<ExpressionContext>& expCtx) - : CmdWithLetShape(aggregateCommand.getLet(), - expCtx, - _components, - std::move(origNss), - aggregateCommand.getCollation().value_or(BSONObj())), - _components(aggregateCommand, - std::move(involvedNamespaces_), - pipeline.serializeToBson( - SerializationOptions::kRepresentativeQueryShapeSerializeOptions)), - _inMongos(expCtx->inMongos) {} - -size_t AggCmdShape::extraSize() const { - // To account for possible padding, we calculate the extra space with the difference instead of - // using sizeof(bool); - return sizeof(AggCmdShape) - sizeof(CmdWithLetShape) - sizeof(AggCmdShapeComponents); -} - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/agg_cmd_shape.h b/src/mongo/db/query/query_shape/agg_cmd_shape.h deleted file mode 100644 index c0ef5a7b06f..00000000000 --- a/src/mongo/db/query/query_shape/agg_cmd_shape.h +++ /dev/null @@ -1,103 +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. - */ - -#pragma once - -#include <boost/intrusive_ptr.hpp> - -#include "mongo/db/pipeline/aggregate_command_gen.h" -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/pipeline/pipeline.h" -#include "mongo/db/query/query_shape/cmd_with_let_shape.h" -#include "mongo/db/query/query_shape/query_shape.h" - -namespace mongo::query_shape { - -/** - * A struct representing the aggregate command's specific components that are to be considered part - * of the query shape. - * - * This struct stores the shapified version of the pipeline as a memory optimization. We'll need to - * store the BSON version in either case, since often the parsed version needs that BSON to survive - * as backing memory, so we store the representative pipeline shape so that we are able to parse the - * pipeline again if we need to compute a different shape. - */ -struct AggCmdShapeComponents : public query_shape::CmdSpecificShapeComponents { - AggCmdShapeComponents(const AggregateCommandRequest&, - stdx::unordered_set<NamespaceString> involvedNamespaces, - std::vector<BSONObj> shapifiedPipeline); - - AggCmdShapeComponents(OptionalBool allowDiskUse, - stdx::unordered_set<NamespaceString> involvedNamespaces, - std::vector<BSONObj> shapifiedPipeline); - - size_t size() const final; - - void appendTo(BSONObjBuilder&) const; - - void HashValue(absl::HashState state) const final; - - OptionalBool allowDiskUse; - - stdx::unordered_set<NamespaceString> involvedNamespaces; - - // The representative query shape of the pipeline. - std::vector<BSONObj> representativePipeline; -}; - -/** - * A class representing the query shape of an aggregate command. The components are listed above. - * This class knows how to utilize those components to serialize to BSON with any - * SerializationOptions. Mostly this involves correctly setting up an ExpressionContext to re-parse - * the request if needed. - */ -class AggCmdShape : public CmdWithLetShape { -public: - AggCmdShape(const AggregateCommandRequest&, - NamespaceString origNss, - stdx::unordered_set<NamespaceString> involvedNamespaces, - const Pipeline&, - const boost::intrusive_ptr<ExpressionContext>&); - - void appendLetCmdSpecificShapeComponents(BSONObjBuilder& bob, - const boost::intrusive_ptr<ExpressionContext>&, - const SerializationOptions&) const final; - size_t extraSize() const final override; - -private: - AggCmdShapeComponents _components; - // Flag to denote if the query was run on mongos. Needed to rebuild the "dummy" expression - // context for re-parsing. - bool _inMongos; -}; -static_assert(sizeof(AggCmdShape) <= - sizeof(CmdWithLetShape) + sizeof(AggCmdShapeComponents) + 8 /* bool and padding*/, - "If the class' members have changed, this assert and the extraSize() calculation may " - "need to be updated with a new value."); -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/agg_cmd_shape_test.cpp b/src/mongo/db/query/query_shape/agg_cmd_shape_test.cpp deleted file mode 100644 index c617391f4e7..00000000000 --- a/src/mongo/db/query/query_shape/agg_cmd_shape_test.cpp +++ /dev/null @@ -1,266 +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 "mongo/bson/json.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_shape/agg_cmd_shape.h" -#include "mongo/db/query/query_shape/cmd_with_let_shape.h" -#include "mongo/db/query/query_test_service_context.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_shape { - -namespace { -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - -class AggCmdShapeTest : public unittest::Test { -public: - void setUp() final { - _queryTestServiceContext = std::make_unique<QueryTestServiceContext>(); - _operationContext = _queryTestServiceContext->makeOperationContext(); - _expCtx = make_intrusive<ExpressionContextForTest>(); - } - - std::unique_ptr<AggregateCommandRequest> makeAggregateCommandRequest( - std::vector<StringData> stagesJson, - boost::optional<StringData> letJson = boost::none, - boost::optional<StringData> collationJson = boost::none) { - std::vector<BSONObj> pipeline; - for (auto&& stage : stagesJson) { - pipeline.push_back(fromjson(stage.rawData())); - } - - auto aggRequest = - std::make_unique<AggregateCommandRequest>(kDefaultTestNss, std::move(pipeline)); - if (letJson) { - aggRequest->setLet(fromjson(letJson->rawData())); - } - if (collationJson) { - aggRequest->setCollation(fromjson(collationJson->rawData())); - } - return aggRequest; - } - - std::unique_ptr<AggCmdShape> makeShapeFromPipeline( - std::vector<StringData> stagesJson, - boost::optional<StringData> letJson = boost::none, - boost::optional<StringData> collationJson = boost::none) { - - auto aggRequest = makeAggregateCommandRequest( - std::move(stagesJson), std::move(letJson), std::move(collationJson)); - - auto parsedPipeline = Pipeline::parse(aggRequest->getPipeline(), _expCtx); - return std::make_unique<AggCmdShape>(*aggRequest, - kDefaultTestNss, - stdx::unordered_set<NamespaceString>{kDefaultTestNss}, - *parsedPipeline, - _expCtx); - } - std::unique_ptr<AggCmdShapeComponents> makeShapeComponentsFromPipeline( - std::vector<StringData> stagesJson, OptionalBool allowDiskUse = {}) { - auto aggRequest = makeAggregateCommandRequest(std::move(stagesJson)); - - auto parsedPipeline = Pipeline::parse(aggRequest->getPipeline(), _expCtx); - return std::make_unique<AggCmdShapeComponents>( - *aggRequest, - stdx::unordered_set<NamespaceString>{kDefaultTestNss}, - parsedPipeline->serializeToBson( - SerializationOptions::kRepresentativeQueryShapeSerializeOptions)); - } - - std::unique_ptr<QueryTestServiceContext> _queryTestServiceContext; - - ServiceContext::UniqueOperationContext _operationContext; - boost::intrusive_ptr<ExpressionContext> _expCtx; -}; - -TEST_F(AggCmdShapeTest, BasicPipelineShape) { - auto shape = - makeShapeFromPipeline({R"({$match: {x: 3, y: {$lte: 3}}})"_sd, - R"({$group: {_id: "$y", z: {$max: "$z"}, w: {$avg: "$w"}}})"}); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "x": { - "$eq": "?number" - } - }, - { - "y": { - "$lte": "?number" - } - } - ] - } - }, - { - "$group": { - "_id": "$y", - "z": { - "$max": "$z" - }, - "w": { - "$avg": "$w" - } - } - } - ] - })", - shape->toBson(_operationContext.get(), - SerializationOptions::kDebugQueryShapeSerializeOptions)); -} - -TEST_F(AggCmdShapeTest, IncludesLet) { - auto shape = makeShapeFromPipeline({R"({$match: {x: 3}})"_sd, R"({$limit: 2})"_sd}, - R"({x: 4, y: "str"})"_sd); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "let": { - "x": "?number", - "y": "?string" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "x": { - "$eq": "?number" - } - } - }, - { - "$limit": "?number" - } - ] - })", - shape->toBson(_operationContext.get(), - SerializationOptions::kDebugQueryShapeSerializeOptions)); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "let": { - "x": { - "$const": 1 - }, - "y": { - "$const": "?" - } - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "x": { - "$eq": 1 - } - } - }, - { - "$limit": 1 - } - ] - })", - shape->toBson(_operationContext.get(), - SerializationOptions::kRepresentativeQueryShapeSerializeOptions)); -} - -TEST_F(AggCmdShapeTest, SizeOfAggCmdShapeComponents) { - auto aggComponents = makeShapeComponentsFromPipeline( - {R"({$match: {x: 3, y: {$lte: 3}}})"_sd, - R"({$group: {_id: "$y", z: {$max: "$z"}, w: {$avg: "$w"}}})"}, - false /*allowDiskUse*/); - - // The sizes of any members of AggCmdShapeComponents are typically accounted for by - // sizeof(AggCmdShapeComponents). The important part of the test here is to ensure that any - // additional memory allocations are also included in the size() operation. In our case, - // we expect additional memory use from the representative pipeline and the involved - // namespaces set. - const auto pipelineSize = shape_helpers::containerSize(aggComponents->representativePipeline); - const auto involvedNamespacesSize = sizeof(kDefaultTestNss) + - kDefaultTestNss.size(); // kDefaultTestNss is the only value in the unordered set. - - ASSERT_EQ(aggComponents->size(), - sizeof(AggCmdShapeComponents) + pipelineSize + involvedNamespacesSize); -} - -TEST_F(AggCmdShapeTest, EquivalentAggCmdShapeComponentSizes) { - auto aggComponentsDiskUseFalse = makeShapeComponentsFromPipeline( - {R"({$match: {x: 3, y: {$lte: 3}}})"_sd, - R"({$group: {_id: "$y", z: {$max: "$z"}, w: {$avg: "$w"}}})"}, - false /*allowDiskUse*/); - auto aggComponentsDiskUseTrue = makeShapeComponentsFromPipeline( - {R"({$match: {x: 3, y: {$lte: 3}}})"_sd, - R"({$group: {_id: "$y", z: {$max: "$z"}, w: {$avg: "$w"}}})"}, - true /*allowDiskUse*/); - ASSERT_EQ(aggComponentsDiskUseFalse->size(), aggComponentsDiskUseTrue->size()); -} - -TEST_F(AggCmdShapeTest, DifferentAggCmdShapeComponentSizes) { - auto smallAggComponents = makeShapeComponentsFromPipeline({R"({$match: {x: 3, y: {$lte: 3}}})"}, - false /*allowDiskUse*/); - auto largeAggComponents = makeShapeComponentsFromPipeline( - {R"({$match: {x: 3, y: {$lte: 3}}})"_sd, - R"({$group: {_id: "$y", z: {$max: "$z"}, w: {$avg: "$w"}}})"}, - false /*allowDiskUse*/); - ASSERT_LT(smallAggComponents->size(), largeAggComponents->size()); -} - -TEST_F(AggCmdShapeTest, SizeOfAggCmdShapeWithAndWithoutLet) { - auto shapeWithoutLet = makeShapeFromPipeline({R"({$match: {x: 3}})"_sd, R"({$limit: 2})"_sd}); - auto shapeWithLet = makeShapeFromPipeline({R"({$match: {x: 3}})"_sd, R"({$limit: 2})"_sd}, - R"({x: 4, y: "str"})"_sd); - ASSERT_LT(shapeWithoutLet->size(), shapeWithLet->size()); -} - -TEST_F(AggCmdShapeTest, SizeOfAggCmdShapeWithAndWithoutCollation) { - auto shapeWithoutCollation = - makeShapeFromPipeline({R"({$match: {x: 3}})"_sd, R"({$limit: 2})"_sd}); - auto shapeWithCollation = makeShapeFromPipeline( - {R"({$match: {x: 3}})"_sd, R"({$limit: 2})"_sd}, boost::none, R"({locale: "en_US"})"_sd); - ASSERT_LT(shapeWithoutCollation->size(), shapeWithCollation->size()); -} -} // namespace -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/cmd_with_let_shape.cpp b/src/mongo/db/query/query_shape/cmd_with_let_shape.cpp deleted file mode 100644 index 2bbb6dfeadc..00000000000 --- a/src/mongo/db/query/query_shape/cmd_with_let_shape.cpp +++ /dev/null @@ -1,107 +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 "mongo/db/query/query_shape/cmd_with_let_shape.h" - -namespace mongo::query_shape { - -namespace { -BSONObj extractLetShape(BSONObj letSpec, - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx) { - if (letSpec.isEmpty()) { - // Fast path for the common case. - return letSpec; - } - - BSONObjBuilder bob; - for (BSONElement elem : letSpec) { - auto expr = Expression::parseOperand(expCtx.get(), elem, expCtx->variablesParseState); - auto redactedValue = expr->serialize(opts); - // Note that this will throw on deeply nested let variables. - redactedValue.addToBsonObj(&bob, opts.serializeFieldPathFromString(elem.fieldName())); - } - return bob.obj(); -} - -auto representativeLetShape(boost::optional<BSONObj> let, - const boost::intrusive_ptr<ExpressionContext>& expCtx) { - return let ? extractLetShape( - *let, SerializationOptions::kRepresentativeQueryShapeSerializeOptions, expCtx) - : BSONObj(); -} -} // namespace - -LetShapeComponent::LetShapeComponent(boost::optional<BSONObj> let, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const CmdSpecificShapeComponents& unownedInnerComponents_) - : shapifiedLet(representativeLetShape(let, expCtx)), - hasLet(bool(let)), - unownedInnerComponents(unownedInnerComponents_) {} - -void LetShapeComponent::HashValue(absl::HashState state) const { - state = absl::HashState::combine( - std::move(state), hasLet, simpleHash(shapifiedLet), unownedInnerComponents); -} - -size_t LetShapeComponent::size() const { - return sizeof(LetShapeComponent) + shapifiedLet.objsize() + unownedInnerComponents.size(); -} - -void LetShapeComponent::addLetBson(BSONObjBuilder& bob, - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx) const { - if (hasLet) { - auto shapeToAppend = shapifiedLet; - if (opts != SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - // We have the representative query cached/stored here, but the caller is asking for a - // different format, so we must re-compute. - shapeToAppend = extractLetShape(shapifiedLet, opts, expCtx); - } - bob.append(FindCommandRequest::kLetFieldName, shapeToAppend); - } -} - -void CmdWithLetShape::appendCmdSpecificShapeComponents(BSONObjBuilder& bob, - OperationContext* opCtx, - const SerializationOptions& opts) const { - auto expCtx = - ExpressionContext::makeBlankExpressionContext(opCtx, nssOrUUID, _let.shapifiedLet); - _let.addLetBson(bob, opts, expCtx); - appendLetCmdSpecificShapeComponents(bob, expCtx, opts); -} - -CmdWithLetShape::CmdWithLetShape(boost::optional<BSONObj> let, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const CmdSpecificShapeComponents& unownedInnerComponents, - NamespaceStringOrUUID nssOrUUID, - BSONObj collation) - : Shape(nssOrUUID, collation), _let(let, expCtx, unownedInnerComponents) {} - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/cmd_with_let_shape.h b/src/mongo/db/query/query_shape/cmd_with_let_shape.h deleted file mode 100644 index a1c127b9999..00000000000 --- a/src/mongo/db/query/query_shape/cmd_with_let_shape.h +++ /dev/null @@ -1,109 +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. - */ - -#pragma once - -#include "mongo/bson/bsonobj.h" -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/query/parsed_find_command.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/serialization_options.h" - -namespace mongo::query_shape { - -/** - * This struct is bit of a weird one. We want to use it as the shape's _entire_ "specific - * components" (rather than introduce more virtual functions to that interface). So, we track here - * the let component (as the name suggests) but we also keep an unowned reference to the specific - * components of CmdWithLetShape sub-classes. This class doesn't really do all that much with those - * components except track a reference to them and ensure their size is accounted for and their hash - * value is incorporated. - */ -struct LetShapeComponent : public CmdSpecificShapeComponents { - LetShapeComponent(boost::optional<BSONObj> let, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const CmdSpecificShapeComponents& unownedInnerComponents); - - /** - * Hashes to include the shapified let parameters and also the hash of 'unownedInnerComponents'. - */ - void HashValue(absl::HashState state) const final; - - /** - * Includes the size of the let parameters and the size of 'unownedInnerComponents.' - */ - size_t size() const final; - - /** - * Adds _only_ the let params. - */ - void addLetBson(BSONObjBuilder&, - const SerializationOptions&, - const boost::intrusive_ptr<ExpressionContext>&) const; - - BSONObj shapifiedLet; - bool hasLet; - // Tracked so that this can be hash combined correctly. - const CmdSpecificShapeComponents& unownedInnerComponents; -}; - -/** - * The 'let' command argument is semi-generic in that it is supported in a couple commands. However - * it is treated specially since it supports using expressions as the let constants. Using - * expressions induces a library dependency that we don't want in the Shape interface itself. So - * this class handles tracking and adding the 'let' component of the shape for sub-classes. - */ -class CmdWithLetShape : public Shape { -public: - CmdWithLetShape(boost::optional<BSONObj> let, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const CmdSpecificShapeComponents& unownedInnerComponents, - NamespaceStringOrUUID, - BSONObj collation_); - - const CmdSpecificShapeComponents& specificComponents() const final { - return _let; - } - -protected: - void appendCmdSpecificShapeComponents(BSONObjBuilder&, - OperationContext* opCtx, - const SerializationOptions& opts) const final; - virtual void appendLetCmdSpecificShapeComponents( - BSONObjBuilder&, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions&) const = 0; - - LetShapeComponent _let; -}; -static_assert(sizeof(CmdWithLetShape) == sizeof(Shape) + sizeof(LetShapeComponent), - "If the class' members have changed, this assert and the extraSize() calculation may " - "need to be updated with a new value."); - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/cmd_with_let_shape_test.cpp b/src/mongo/db/query/query_shape/cmd_with_let_shape_test.cpp deleted file mode 100644 index 21812d97fc7..00000000000 --- a/src/mongo/db/query/query_shape/cmd_with_let_shape_test.cpp +++ /dev/null @@ -1,78 +0,0 @@ -/** - * Copyright (C) 2024-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 "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_shape/cmd_with_let_shape.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_shape { - -namespace { -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - -class CmdWithLetShapeTest : public unittest::Test {}; - - -struct DummyInnerComponent : public CmdSpecificShapeComponents { - DummyInnerComponent(){}; - void HashValue(absl::HashState state) const {} - size_t size() const final { - return sizeof(*this); - } -}; - -TEST_F(CmdWithLetShapeTest, SizeOfLetShapeComponent) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto let = fromjson(R"({x: 4, y: "str"})"); - auto innerComponents = std::make_unique<DummyInnerComponent>(); - auto components = std::make_unique<LetShapeComponent>(let, expCtx, *innerComponents); - - const auto minimumSize = sizeof(CmdSpecificShapeComponents) + sizeof(BSONObj) + sizeof(bool) + - sizeof(void*) /*CmdSpecificShapeComponents&*/ + - static_cast<size_t>(components->shapifiedLet.objsize()) + - components->unownedInnerComponents.size(); - - ASSERT_GTE(components->size(), minimumSize); - ASSERT_LTE(components->size(), minimumSize + 8 /*padding*/); -} - -TEST_F(CmdWithLetShapeTest, SizeOfComponentWithAndWithoutLet) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto let = fromjson(R"({x: 4, y: "str"})"); - auto innerComponents = std::make_unique<DummyInnerComponent>(); - auto componentsWithLet = std::make_unique<LetShapeComponent>(let, expCtx, *innerComponents); - auto componentsWithNoLet = - std::make_unique<LetShapeComponent>(boost::none, expCtx, *innerComponents); - - ASSERT_LT(componentsWithNoLet->size(), componentsWithLet->size()); -} - -} // namespace -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/find_cmd_shape.cpp b/src/mongo/db/query/query_shape/find_cmd_shape.cpp deleted file mode 100644 index 2d018de2619..00000000000 --- a/src/mongo/db/query/query_shape/find_cmd_shape.cpp +++ /dev/null @@ -1,227 +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 "mongo/db/query/query_shape/find_cmd_shape.h" - -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/query_shape/shape_helpers.h" - -namespace mongo::query_shape { -namespace { - -BSONObj projectionShape(const boost::optional<projection_ast::Projection>& proj, - const SerializationOptions& opts = - SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - return proj ? projection_ast::serialize(*proj->root(), opts) : BSONObj(); -} - -BSONObj sortShape(const boost::optional<SortPattern>& sort, - const SerializationOptions& opts = - SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - return sort - ? sort->serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts) - .toBson() - : BSONObj(); -} - -void maybeAddWithName(const OptionalBool& optBool, BSONObjBuilder& bob, StringData name) { - if (optBool.has_value()) { - bob.append(name, bool(optBool)); - } -} - -void addRemainingFindCommandFields(const FindCmdShapeComponents& components, BSONObjBuilder& bob) { - maybeAddWithName(components.singleBatch, bob, FindCommandRequest::kSingleBatchFieldName); - maybeAddWithName(components.allowDiskUse, bob, FindCommandRequest::kAllowDiskUseFieldName); - maybeAddWithName(components.returnKey, bob, FindCommandRequest::kReturnKeyFieldName); - maybeAddWithName(components.showRecordId, bob, FindCommandRequest::kShowRecordIdFieldName); - maybeAddWithName(components.tailable, bob, FindCommandRequest::kTailableFieldName); - maybeAddWithName(components.awaitData, bob, FindCommandRequest::kAwaitDataFieldName); - maybeAddWithName(components.oplogReplay, bob, FindCommandRequest::kOplogReplayFieldName); -} - -} // namespace - -FindCmdShapeComponents::FindCmdShapeComponents( - const ParsedFindCommand& request, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts) - : filter(request.filter->serialize(opts)), - projection(projectionShape(request.proj, opts)), - sort(sortShape(request.sort, opts)), - min(shape_helpers::extractMinOrMaxShape(request.findCommandRequest->getMin(), opts)), - max(shape_helpers::extractMinOrMaxShape(request.findCommandRequest->getMax(), opts)), - singleBatch(request.findCommandRequest->getSingleBatch()), - allowDiskUse(request.findCommandRequest->getAllowDiskUse().has_value() - ? boost::optional<bool>(bool(request.findCommandRequest->getAllowDiskUse())) - : boost::none), - returnKey(request.findCommandRequest->getReturnKey()), - showRecordId(request.findCommandRequest->getShowRecordId()), - tailable(request.findCommandRequest->getTailable()), - awaitData(request.findCommandRequest->getAwaitData()), - oplogReplay(request.findCommandRequest->getOplogReplay()), - hasField(), - serializationOpts(opts) { - hasField.projection = request.proj.has_value(); - hasField.sort = request.sort.has_value(); - hasField.limit = request.findCommandRequest->getLimit().has_value(); - hasField.skip = request.findCommandRequest->getSkip().has_value(); -} - -void FindCmdShapeComponents::appendTo(BSONObjBuilder& bob) const { - - bob.append("command", "find"); - - std::unique_ptr<MatchExpression> filterExpr; - // Filter. - bob.append(FindCommandRequest::kFilterFieldName, filter); - - if (hasField.projection) { - bob.append(FindCommandRequest::kProjectionFieldName, projection); - } - - if (!max.isEmpty()) { - bob.append(FindCommandRequest::kMaxFieldName, max); - } - if (!min.isEmpty()) { - bob.append(FindCommandRequest::kMinFieldName, min); - } - - // Sort. - if (hasField.sort) { - bob.append(FindCommandRequest::kSortFieldName, sort); - } - - // The values here don't matter (assuming we're not using the 'kUnchanged' policy). - tassert(7973601, - "Serialization policy not supported - original values have been discarded", - serializationOpts.literalPolicy != LiteralSerializationPolicy::kUnchanged); - if (hasField.limit) { - serializationOpts.appendLiteral(&bob, FindCommandRequest::kLimitFieldName, 1ll); - } - if (hasField.skip) { - serializationOpts.appendLiteral(&bob, FindCommandRequest::kSkipFieldName, 1ll); - } - - // Add the fields that require no transformation. - addRemainingFindCommandFields(*this, bob); -} - -void FindCmdShapeComponents::HashValue(absl::HashState state) const { - absl::HashState::combine(std::move(state), - simpleHash(filter), - simpleHash(projection), - simpleHash(sort), - simpleHash(min), - simpleHash(max), - singleBatch, - allowDiskUse, - returnKey, - showRecordId, - tailable, - awaitData, - oplogReplay, - hasField); -} - -std::unique_ptr<FindCommandRequest> FindCmdShape::toFindCommandRequest() const { - auto fcr = std::make_unique<FindCommandRequest>(nssOrUUID); - - fcr->setFilter(components.filter); - if (components.hasField.projection) - fcr->setProjection(components.projection); - if (components.hasField.sort) - fcr->setSort(components.sort); - - fcr->setMin(components.min); - fcr->setMax(components.max); - - // Doesn't matter what value to use for limit and skip in the context of a shape. - if (components.hasField.limit) - fcr->setLimit(1ll); - if (components.hasField.skip) - fcr->setSkip(1ll); - - // All the booleans. - if (components.singleBatch.has_value()) - fcr->setSingleBatch(bool(components.singleBatch)); - if (components.allowDiskUse.has_value()) - fcr->setAllowDiskUse(bool(components.allowDiskUse)); - if (components.returnKey.has_value()) - fcr->setReturnKey(bool(components.returnKey)); - if (components.showRecordId.has_value()) - fcr->setShowRecordId(bool(components.showRecordId)); - if (components.tailable.has_value()) - fcr->setTailable(bool(components.tailable)); - if (components.awaitData.has_value()) - fcr->setAwaitData(bool(components.awaitData)); - if (components.oplogReplay.has_value()) - fcr->setOplogReplay(bool(components.oplogReplay)); - - // Common shape components. - if (_let.hasLet) - fcr->setLet(_let.shapifiedLet); - if (!collation.isEmpty()) - fcr->setCollation(collation); - - - return fcr; -} - -FindCmdShape::FindCmdShape(const ParsedFindCommand& findRequest, - const boost::intrusive_ptr<ExpressionContext>& expCtx) - : CmdWithLetShape(findRequest.findCommandRequest->getLet(), - expCtx, - components, - findRequest.findCommandRequest->getNamespaceOrUUID(), - findRequest.findCommandRequest->getCollation()), - components(findRequest, expCtx) {} - -void FindCmdShape::appendLetCmdSpecificShapeComponents( - BSONObjBuilder& bob, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts) const { - if (opts == SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - // Fast path: we already have this. - return components.appendTo(bob); - } else { - // Slow path: we need to re-parse from our representative shapes. - auto request = uassertStatusOKWithContext( - parsed_find_command::parse(expCtx, - toFindCommandRequest(), - ExtensionsCallbackNoop(), - MatchExpressionParser::kAllowAllSpecialFeatures), - "Could not re-parse a representative query shape"); - - // This constructor will shapify according to the options. - FindCmdShapeComponents{*request, expCtx, opts}.appendTo(bob); - } -} - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/find_cmd_shape.h b/src/mongo/db/query/query_shape/find_cmd_shape.h deleted file mode 100644 index 49d70b8ec27..00000000000 --- a/src/mongo/db/query/query_shape/find_cmd_shape.h +++ /dev/null @@ -1,130 +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. - */ - -#pragma once - -#include "mongo/db/query/query_shape/cmd_with_let_shape.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/shape_helpers.h" - -namespace mongo::query_shape { - -/** - * This struct tracks the components of a find command which are important for the find query shape. - * It attempts to only track those which are _unique_ to a find command - common elements should go - * on some super class. - * - * Data elements which are shapified like 'filter' are stored in their shapified form. By default - * and in most cases this will be the representative query shape form so that it can be re-parsed, - * but as a convenience for serializing it is also supported to construct and serialize this with - * other options. - */ -struct FindCmdShapeComponents : public CmdSpecificShapeComponents { - - FindCmdShapeComponents(const ParsedFindCommand& request, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts = - SerializationOptions::kRepresentativeQueryShapeSerializeOptions); - - /** - * Appends using the SerializationOptions given in the constructor. - */ - void appendTo(BSONObjBuilder&) const; - - size_t size() const final { - return sizeof(FindCmdShapeComponents) + filter.objsize() + projection.objsize() + - sort.objsize() + min.objsize() + max.objsize(); - } - - BSONObj filter; - BSONObj projection; - BSONObj sort; - BSONObj min; - BSONObj max; - - OptionalBool singleBatch; - OptionalBool allowDiskUse; - OptionalBool returnKey; - OptionalBool showRecordId; - OptionalBool tailable; - OptionalBool awaitData; - OptionalBool oplogReplay; - - // This anonymous struct represents the presence of the member variables as C++ bit fields. - // In doing so, each of these boolean values takes up 1 bit instead of 1 byte. - struct HasField { - HasField() : projection(false), sort(false), limit(false), skip(false) {} - bool projection : 1; - bool sort : 1; - bool limit : 1; - bool skip : 1; - } hasField; - - // We save a copy of the options used when constructed so we know how to properly append things - // like limit and skip - either a 1 or "?number". We could have the caller pass the options - // again during 'appendTo()', but this introduces a risk that the options provided are different - // than the ones we used to compute 'filter' and the other components. - SerializationOptions serializationOpts; - - void HashValue(absl::HashState state) const final; -}; - -class FindCmdShape : public CmdWithLetShape { -public: - FindCmdShape(const ParsedFindCommand& findRequest, - const boost::intrusive_ptr<ExpressionContext>& expCtx); - - /** - * Assembles a parseable FindCommandRequest representing this shape - some of the pieces are - * stored right here in the shape, others are in parent classes. - */ - std::unique_ptr<FindCommandRequest> toFindCommandRequest() const; - - FindCmdShapeComponents components; - -protected: - void appendLetCmdSpecificShapeComponents(BSONObjBuilder& bob, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const SerializationOptions& opts) const final; -}; - -template <typename H> -H AbslHashValue(H h, const FindCmdShapeComponents::HasField& hasField) { - return H::combine( - std::move(h), hasField.projection, hasField.sort, hasField.limit, hasField.skip); -} - -// This assertion is still active on the maintained master branch. On the v6.0 branch, we disable it -// since it is not passing on all toolchains/platforms - notably x86 macOS. The intent of the -// assertion is to prevent accidental additions of data members, which should not happen on this -// branch without first happening on the master branch and passing that assertion. -// static_assert(sizeof(FindCmdShape) == sizeof(CmdWithLetShape) + sizeof(FindCmdShapeComponents), -// "If the class' members have changed, this assert and the extraSize() calculation -// may " "need to be updated with a new value."); -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/find_cmd_shape_test.cpp b/src/mongo/db/query/query_shape/find_cmd_shape_test.cpp deleted file mode 100644 index 0d839a5d3d2..00000000000 --- a/src/mongo/db/query/query_shape/find_cmd_shape_test.cpp +++ /dev/null @@ -1,238 +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 "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_shape/find_cmd_shape.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_shape { - -namespace { -/** - * TODO this was stolen from another test. Time for a library? - * Simplistic redaction strategy for testing which appends the field name to the prefix "REDACT_". - */ -std::string applyHmacForTest(StringData sd) { - return "REDACT_" + sd.toString(); -} - -static const NamespaceStringOrUUID kDefaultTestNss = - NamespaceStringOrUUID{NamespaceString("testDB.testColl")}; - -struct RequestOptions { - OptionalBool singleBatch = {}; - OptionalBool allowDiskUse = {}; - OptionalBool returnKey = {}; - OptionalBool showRecordId = {}; - OptionalBool tailable = {}; - OptionalBool awaitData = {}; - OptionalBool limit = {}; - OptionalBool skip = {}; -}; -class FindCmdShapeTest : public ServiceContextTest { -public: - void setUp() final { - _expCtx = make_intrusive<ExpressionContextForTest>(); - } - - std::unique_ptr<FindCmdShape> makeShapeFromSort(StringData sortJson) { - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setSort(fromjson(sortJson.rawData())); - auto&& parsedRequest = - uassertStatusOK(::mongo::parsed_find_command::parse(_expCtx, std::move(fcr))); - return std::make_unique<FindCmdShape>(*parsedRequest, _expCtx); - } - - BSONObj sortShape(StringData sortJson) { - auto shape = makeShapeFromSort(sortJson); - return shape->components.sort; - } - - /** - * Returns the shape of the input sort, or boost::none if the input shape was a natural sort - * which got converted into a hint. - */ - boost::optional<BSONObj> maybeRedactedSortShape(StringData sortJson) { - auto shape = makeShapeFromSort(sortJson); - SerializationOptions opts = SerializationOptions::kDebugQueryShapeSerializeOptions; - opts.transformIdentifiers = true; - opts.transformIdentifiersCallback = applyHmacForTest; - auto shapeBson = shape->toBson(_expCtx->opCtx, opts); - if (auto sortElem = shapeBson["sort"]; !sortElem.eoo()) { - return sortElem.Obj().getOwned(); - } - return boost::none; - } - - BSONObj redactedSortShape(StringData sortJson) { - return *maybeRedactedSortShape(sortJson); - } - - boost::intrusive_ptr<ExpressionContext> _expCtx; - - std::unique_ptr<FindCmdShapeComponents> makeShapeComponentsFromFilter( - BSONObj filter, const RequestOptions& requestOptions = {}) { - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - fcr->setSingleBatch(requestOptions.singleBatch); - fcr->setAllowDiskUse(requestOptions.allowDiskUse); - fcr->setReturnKey(requestOptions.returnKey); - fcr->setAllowDiskUse(requestOptions.showRecordId); - fcr->setTailable(requestOptions.tailable); - fcr->setAwaitData(requestOptions.awaitData); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(_expCtx, {std::move(fcr)})); - return std::make_unique<FindCmdShapeComponents>(*parsedFind, _expCtx); - } - - std::unique_ptr<FindCmdShape> makeShapeFromFilter(const BSONObj& filter) { - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(_expCtx, {std::move(fcr)})); - return std::make_unique<FindCmdShape>(*parsedFind, _expCtx); - } -}; - -TEST_F(FindCmdShapeTest, NormalSortPattern) { - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({"a.b.c":1,"foo":-1})", - sortShape(R"({"a.b.c": 1, "foo": -1})")); -} - -TEST_F(FindCmdShapeTest, NaturalSortPattern) { - // $natural sorts are interpreted as a hint. Hints are not part of the shape (but should show up - // in the query stats key). - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({})", - sortShape(R"({$natural: 1})")); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({})", - sortShape(R"({$natural: -1})")); -} - -TEST_F(FindCmdShapeTest, NaturalSortPatternWithMeta) { - ASSERT_THROWS_CODE( - sortShape(R"({$natural: 1, x: {$meta: "textScore"}})"), DBException, ErrorCodes::BadValue); -} - -TEST_F(FindCmdShapeTest, MetaPatternWithoutNatural) { - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({"normal":1,"$computed1":{"$meta":"textScore"}})", - sortShape(R"({normal: 1, x: {$meta: "textScore"}})")); -} - -// Here we have one test to ensure that the redaction policy is accepted and applied in the -// query_shape utility, but there are more extensive redaction tests in sort_pattern_test.cpp -TEST_F(FindCmdShapeTest, RespectsRedactionPolicy) { - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({"REDACT_normal":1,"REDACT_y":1})", - redactedSortShape(R"({normal: 1, y: 1})")); - - // No need to redact $natural. Again, this will be interpreted as a hint, but this test is - // interesting to ensure the $-prefix of $natural doesn't confuse us. - ASSERT(!maybeRedactedSortShape(R"({$natural: 1})")); -} - -TEST_F(FindCmdShapeTest, SizeOfShapeComponents) { - auto query = BSON("query" << 1 << "xEquals" << 42); - auto findCmdComponent = makeShapeComponentsFromFilter(query.getOwned()); - const auto querySize = findCmdComponent->filter.objsize(); - - const auto minimumSize = sizeof(FindCmdShapeComponents) + querySize; - ASSERT_GT(findCmdComponent->size(), minimumSize); - ASSERT_LTE(findCmdComponent->size(), - minimumSize + static_cast<size_t>(4 * BSONObj().objsize())); -} - -TEST_F(FindCmdShapeTest, EquivalentShapeComponentsSizes) { - auto query = BSON("query" << 1 << "xEquals" << 42); - // Tailable can not be set together with 'singleBatch' option. - auto mostlyTrueComponent = makeShapeComponentsFromFilter(query.getOwned(), - {/* singleBatch = */ false, - /* allowDiskUse = */ true, - /* returnKey = */ true, - /* showRecordId = */ true, - /* tailable = */ true, - /* awaitData = */ true, - /* limit = */ true, - /* skip = */ true}); - - auto mostlyFalseComponent = makeShapeComponentsFromFilter(query.getOwned(), - {/* singleBatch = */ false, - /* allowDiskUse = */ false, - /* returnKey = */ false, - /* showRecordId = */ false, - /* tailable = */ true, - /* awaitData = */ false, - /* limit = */ false, - /* skip = */ false}); - - ASSERT_EQ(mostlyTrueComponent->size(), mostlyFalseComponent->size()); -} - -TEST_F(FindCmdShapeTest, DifferentShapeComponentsSizes) { - auto smallQuery = BSON("query" << BSONObj()); - auto smallFindCmdComponent = makeShapeComponentsFromFilter(smallQuery.getOwned()); - - auto largeQuery = BSON("query" << 1 << "xEquals" << 42); - auto largeFindCmdComponent = makeShapeComponentsFromFilter(largeQuery.getOwned()); - - ASSERT_LT(smallQuery.objsize(), largeQuery.objsize()); - ASSERT_LT(smallFindCmdComponent->size(), largeFindCmdComponent->size()); -} - -TEST_F(FindCmdShapeTest, SizeOfShapeWithAndWithoutLet) { - auto filter = BSON("query" << 1 << "xEquals" << 42); - auto shapeWithoutLet = makeShapeFromFilter(filter.getOwned()); - - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - fcr->setLet(fromjson(R"({x: 4})")); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(_expCtx, {std::move(fcr)})); - auto shapeWithLet = std::make_unique<FindCmdShape>(*parsedFind, _expCtx); - - ASSERT_LT(shapeWithoutLet->size(), shapeWithLet->size()); -} - -TEST_F(FindCmdShapeTest, SizeOfShapeWithAndWithoutCollation) { - auto filter = BSON("query" << 1 << "xEquals" << 42); - auto shapeWithoutCollation = makeShapeFromFilter(filter.getOwned()); - - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - fcr->setCollation(fromjson(R"({locale: "en_US"})")); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(_expCtx, {std::move(fcr)})); - auto shapeWithCollation = std::make_unique<FindCmdShape>(*parsedFind, _expCtx); - - ASSERT_LT(shapeWithoutCollation->size(), shapeWithCollation->size()); -} - -} // namespace - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/query_shape.cpp b/src/mongo/db/query/query_shape/query_shape.cpp deleted file mode 100644 index 2fa0520120e..00000000000 --- a/src/mongo/db/query/query_shape/query_shape.cpp +++ /dev/null @@ -1,103 +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 "mongo/db/query/query_shape/query_shape.h" - -#include "mongo/base/status.h" -#include "mongo/crypto/sha256_block.h" -#include "mongo/db/query/find_command_gen.h" -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/query_request_helper.h" -#include "mongo/db/query/query_shape/agg_cmd_shape.h" -#include "mongo/db/query/query_shape/find_cmd_shape.h" -#include "mongo/db/query/query_shape/query_shape_gen.h" -#include "mongo/db/query/query_shape/shape_helpers.h" -#include "mongo/db/query/sort_pattern.h" - -namespace mongo::query_shape { - -namespace { -void appendCmdNs(BSONObjBuilder& bob, - const NamespaceString& nss, - const SerializationOptions& opts) { - BSONObjBuilder nsObj = bob.subobjStart("cmdNs"); - shape_helpers::appendNamespaceShape(nsObj, nss, opts); - nsObj.doneFast(); -} -} // namespace - -Shape::Shape(NamespaceStringOrUUID nssOrUUID_, BSONObj collation_) - : nssOrUUID(nssOrUUID_), collation(std::move(collation_)) {} - - -BSONObj Shape::toBson(OperationContext* opCtx, const SerializationOptions& opts) const { - BSONObjBuilder bob; - appendCmdNsOrUUID(bob, opts); - if (!collation.isEmpty()) { - // Collation is never shapified. We use find command's collation name definition, but it - // should be the same for all requests. - bob.append(FindCommandRequest::kCollationFieldName, collation); - } - appendCmdSpecificShapeComponents(bob, opCtx, opts); - return bob.obj(); -} - -size_t Shape::size() const { - return sizeof(Shape) + shape_helpers::optionalObjSize(collation) + specificComponents().size() + - extraSize(); -} - -QueryShapeHash Shape::sha256Hash(OperationContext* opCtx) const { - // The Query Shape Hash should use the representative query shape. - auto serialized = - toBson(opCtx, SerializationOptions::kRepresentativeQueryShapeSerializeOptions); - return SHA256Block::computeHash((const uint8_t*)serialized.sharedBuffer().get(), - serialized.objsize()); -} - -void Shape::appendCmdNsOrUUID(BSONObjBuilder& bob, const SerializationOptions& opts) const { - if (nssOrUUID.nss()) { - appendCmdNs(bob, *nssOrUUID.nss(), opts); - } else { - BSONObjBuilder cmdNs = bob.subobjStart("cmdNs"); - cmdNs.append("uuid", opts.serializeIdentifier(nssOrUUID.uuid()->toString())); - cmdNs.append("db", opts.serializeIdentifier(nssOrUUID.db())); - cmdNs.doneFast(); - } -} - -void Shape::appendCmdNs(BSONObjBuilder& bob, - const NamespaceString& nss, - const SerializationOptions& opts) const { - BSONObjBuilder nsObj = bob.subobjStart("cmdNs"); - shape_helpers::appendNamespaceShape(nsObj, nss, opts); - nsObj.doneFast(); -} - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/query_shape.h b/src/mongo/db/query/query_shape/query_shape.h deleted file mode 100644 index dc83cbab127..00000000000 --- a/src/mongo/db/query/query_shape/query_shape.h +++ /dev/null @@ -1,165 +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. - */ - -#pragma once - -#include "mongo/db/matcher/expression.h" -#include "mongo/db/pipeline/aggregate_command_gen.h" -#include "mongo/db/query/find_command_gen.h" -#include "mongo/db/query/query_request_helper.h" -#include "mongo/db/query/query_shape/shape_helpers.h" - -namespace mongo::query_shape { - -/** - * Each type of "query" command likely has different fields/options that are considered important - * for the shape. For example, a find command has a skip and a limit, and an aggregate command has a - * pipeline. This interface is used to allow different sub-commands to diverge in this way but still - * ensure we can appropriately hash them to compare their shapes, and properly account for their - * size. - * - * This struct is split out as a separate inheritence hierarchy from 'Shape' to make it easier to - * ensure each piece is hashed without sub-classes needing to enumerate the parent class's member - * variables. - */ -struct CmdSpecificShapeComponents { - virtual ~CmdSpecificShapeComponents() {} - - /** - * Sub-classes should implement this in a way which includes all shape-relevant state. If two - * shapes should compare equal, they should result in the same hash value. For example for the - * find command - we would include the _shapified_ filter and projection here, but we will not - * include the comment - which is not part of the shape. - */ - virtual void HashValue(absl::HashState state) const = 0; - - /** - * It is important for shape components to accurately report their size, and to make a - * reasonable effort to maintain a minimal size. We use the query shape in memory-constrained - * data structures, so a bigger shape means we can have fewer different shapes stored (for - * example in the query stats store). - * - * We cannot just use sizeof() because there are some variable size data members (like BSON - * objects) which depend on the particular instance. - */ - virtual size_t size() const = 0; - - // Some template boilerplate to allow sub-classes to overload the hash implementation. - template <typename H> - friend H AbslHashValue(H state, const CmdSpecificShapeComponents& value) { - value.HashValue(absl::HashState::Create(&state)); - return std::move(state); - } -}; - -using QueryShapeHash = SHA256Block; - -/** - * A query "shape" is a version of a command with literal values abstracted so that two instances of - * the command may compare/hash equal even if they use slightly different literal values. This - * concept exists not just the find command, but planned for many of the CRUD commands + aggregate. - * It also includes most (but not all) components of these commands, not just the query predicate - * (MatchExpresssion). In these ways, "query" is meant more generally. - * - * A "Query Shape" can vary depending on the command (e.g. find, aggregate, or distinct). This - * abstract struct is the API we must implement for each command which we want to have a "shape" - * concept. - * - * In order to properly account for the size of a query shape, the CmdSpecificShapeComponents should - * include all meaningful memory consumption, and be sure to report it in 'size()'. Subclasses of - * 'Shape' are not expected to have any meaningful memory usage outside of that struct. - */ -class Shape { -public: - virtual ~Shape() {} - - /** - * Sub-classes are expected to implement this as a mechanism for plugging in their command - * specific shape components. - */ - virtual const CmdSpecificShapeComponents& specificComponents() const = 0; - - /** - * Note this may involve re-parsing command BSON and so is not necessarily cheap. - */ - BSONObj toBson(OperationContext*, const SerializationOptions&) const; - - /** - * The Query Shape Hash is defined to be the SHA256 Hash of the representatice query shape. This - * helper computes that. - */ - QueryShapeHash sha256Hash(OperationContext*) const; - - /** - * The size of a query shape is important, since we store these in space-constrained - * environments like the query stats store. - */ - size_t size() const; - - /** - * This should be overriden by a child class if it has members whose sizes are not included in - * specificComponents().size(). - */ - virtual size_t extraSize() const { - return 0; - } - template <typename H> - friend H AbslHashValue(H h, const Shape& shape) { - h = H::combine(std::move(h), shape.nssOrUUID, shape.specificComponents()); - if (!shape.collation.isEmpty()) - h = H::combine(std::move(h), simpleHash(shape.collation)); - return h; - } - - - // Not shapified but it is an identifier so it may be transformed. - NamespaceStringOrUUID nssOrUUID; - - // Never shapified. If it's empty, leave it off. - BSONObj collation; - -protected: - Shape(NamespaceStringOrUUID, BSONObj collation_); - - /** - * Along with the hash implementation, this is the main way that shapes are 'shapified' - - * sub-classes should implement this to add the shapified versions of their literals to an - * object. Depending on 'opts', this may be eligible to be used for output in $queryStats or as - * the object to compute the QueryShapeHash. - */ - virtual void appendCmdSpecificShapeComponents(BSONObjBuilder&, - OperationContext*, - const SerializationOptions& opts) const = 0; - -private: - void appendCmdNsOrUUID(BSONObjBuilder&, const SerializationOptions&) const; - void appendCmdNs(BSONObjBuilder&, const NamespaceString&, const SerializationOptions&) const; -}; - -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/query_shape.idl b/src/mongo/db/query/query_shape/query_shape.idl deleted file mode 100644 index 77e71756467..00000000000 --- a/src/mongo/db/query/query_shape/query_shape.idl +++ /dev/null @@ -1,50 +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. - -global: - cpp_namespace: "mongo::query_shape" - -imports: - - "mongo/idl/basic_types.idl" - - -structs: - CommandNamespace: - description: "Representation of the cmdNs sub-object of the query shape." - fields: - db: - type: string - coll: - type: string - optional: true - uuid: - type: string - optional: true - tenantId: - type: string - optional: true -
\ No newline at end of file diff --git a/src/mongo/db/query/query_shape/query_shape_test.cpp b/src/mongo/db/query/query_shape/query_shape_test.cpp deleted file mode 100644 index d6185b5c5cb..00000000000 --- a/src/mongo/db/query/query_shape/query_shape_test.cpp +++ /dev/null @@ -1,767 +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 "mongo/bson/bsonmisc.h" -#include "mongo/bson/bsonobj.h" -#include "mongo/db/matcher/expression_geo.h" -#include "mongo/db/matcher/extensions_callback_real.h" -#include "mongo/db/matcher/parsed_match_expression_for_test.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/query_shape_test_gen.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/db/query/query_shape/shape_helpers.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/unittest/bson_test_util.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_shape { - -namespace { -BSONObj predicateShape(const MatchExpression* expr) { - return expr->serialize(SerializationOptions::kDebugQueryShapeSerializeOptions); -} -BSONObj predicateShape(std::string filterJson) { - return predicateShape(ParsedMatchExpressionForTest(filterJson).get()); -} - -BSONObj predicateShapeRedacted(const MatchExpression* expr) { - return expr->serialize(SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST); -} -BSONObj predicateShapeRedacted(std::string filterJson) { - return predicateShapeRedacted(ParsedMatchExpressionForTest(filterJson).get()); -} - -// TODO SERVER-87736 There is no 'auto' here, make that more clear. -#define ASSERT_SHAPE_EQ_AUTO(expected, actual) \ - ASSERT_BSONOBJ_EQ_AUTO(expected, predicateShape(actual)) - -#define ASSERT_REDACTED_SHAPE_EQ_AUTO(expected, actual) \ - ASSERT_BSONOBJ_EQ_AUTO(expected, predicateShapeRedacted(actual)) - - -TEST(QueryPredicateShape, Equals) { - ASSERT_SHAPE_EQ_AUTO( // Implicit equals - R"({"a":{"$eq":"?number"}})", - "{a: 5}"); - ASSERT_SHAPE_EQ_AUTO( // Explicit equals - R"({"a":{"$eq":"?number"}})", - "{a: {$eq: 5}}"); - ASSERT_SHAPE_EQ_AUTO( // implicit $and - R"({"$and":[{"a":{"$eq":"?number"}},{"b":{"$eq":"?number"}}]})", - "{a: 5, b: 6}"); - ASSERT_REDACTED_SHAPE_EQ_AUTO( // Implicit equals - R"({"HASH<a>":{"$eq":"?number"}})", - "{a: 5}"); - ASSERT_REDACTED_SHAPE_EQ_AUTO( // Explicit equals - R"({"HASH<a>":{"$eq":"?number"}})", - "{a: {$eq: 5}}"); - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({"$and":[{"HASH<a>":{"$eq":"?number"}},{"HASH<b>":{"$eq":"?number"}}]})", - "{a: 5, b: 6}"); - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({"HASH<foo>.HASH<$bar>":{"$eq":"?number"}})", - R"({"foo.$bar":0})"); -} - -TEST(QueryPredicateShape, ArraySubTypes) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - "{a: {$eq: '[]'}}", - "{a: []}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - "{a: {$eq: '?array<?number>'}}", - "{a: [2]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<?number>"}})", - "{a: [2, 3]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<?object>"}})", - "{a: [{}]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<?object>"}})", - "{a: [{}, {}]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<?array>"}})", - "{a: [[], [], []]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<?array>"}})", - "{a: [[2, 3], ['string'], []]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<>"}})", - "{a: [{}, 2]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<>"}})", - "{a: [[], 2]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<>"}})", - "{a: [[{}, 'string'], 2]}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$eq":"?array<>"}})", - "{a: [[{}, 'string'], 2]}"); -} - -TEST(QueryPredicateShape, Comparisons) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$lt": "?number" - } - }, - { - "b": { - "$gt": "?number" - } - }, - { - "c": { - "$gte": "?number" - } - }, - { - "c": { - "$lte": "?number" - } - } - ] - })", - "{a: {$lt: 5}, b: {$gt: 6}, c: {$gte: 3, $lte: 10}}"); -} - -namespace { -void assertShapeIs(std::string filterJson, BSONObj expectedShape) { - ASSERT_BSONOBJ_EQ(expectedShape, predicateShape(filterJson)); -} - -void assertRedactedShapeIs(std::string filterJson, BSONObj expectedShape) { - ASSERT_BSONOBJ_EQ(expectedShape, predicateShapeRedacted(filterJson)); -} -} // namespace - -TEST(QueryPredicateShape, Regex) { - // Note/warning: 'fromjson' will parse $regex into a /regex/, so these tests can't use - // auto-updating BSON assertions. - assertShapeIs("{a: /a+/}", - BSON("a" << BSON("$regex" - << "?string"))); - assertShapeIs("{a: /a+/i}", - BSON("a" << BSON("$regex" - << "?string" - << "$options" - << "?string"))); - assertRedactedShapeIs("{a: /a+/}", - BSON("HASH<a>" << BSON("$regex" - << "?string"))); - assertRedactedShapeIs("{a: /a+/}", - BSON("HASH<a>" << BSON("$regex" - << "?string"))); -} - -TEST(QueryPredicateShape, Mod) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$mod":["?number","?number"]}})", - "{a: {$mod: [2, 0]}}"); -} - -TEST(QueryPredicateShape, Exists) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$exists":"?bool"}})", - "{a: {$exists: true}}"); -} - -TEST(QueryPredicateShape, In) { - // Any number of children in any order is always the same shape - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$in":"?array<?number>"}})", - "{a: {$in: [1]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$in":"?array<>"}})", - "{a: {$in: [1, 4, 'str', /regex/]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$in":"?array<>"}})", - "{a: {$in: ['str', /regex/, 1, 4]}}"); -} - -TEST(QueryPredicateShape, BitTestOperators) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAllSet":"?array<?number>"}})", - "{a: {$bitsAllSet: [1, 5]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAllSet":"?array<?number>"}})", - "{a: {$bitsAllSet: 50}}"); - - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAnySet":"?array<?number>"}})", - "{a: {$bitsAnySet: [1, 5]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAnySet":"?array<?number>"}})", - "{a: {$bitsAnySet: 50}}"); - - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAllClear":"?array<?number>"}})", - "{a: {$bitsAllClear: [1, 5]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAllClear":"?array<?number>"}})", - "{a: {$bitsAllClear: 50}}"); - - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAnyClear":"?array<?number>"}})", - "{a: {$bitsAnyClear: [1, 5]}}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$bitsAnyClear":"?array<?number>"}})", - "{a: {$bitsAnyClear: 50}}"); -} - -TEST(QueryPredicateShape, AlwaysBoolean) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"$alwaysTrue":"?number"})", - "{$alwaysTrue: 1}"); - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"$alwaysFalse":"?number"})", - "{$alwaysFalse: 1}"); -} - -TEST(QueryPredicateShape, And) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$lt": "?number" - } - }, - { - "b": { - "$gte": "?number" - } - }, - { - "c": { - "$lte": "?number" - } - } - ] - })", - "{$and: [{a: {$lt: 5}}, {b: {$gte: 3}}, {c: {$lte: 10}}]}"); -} - -TEST(QueryPredicateShape, Or) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({ - "$or": [ - { - "a": { - "$eq": "?number" - } - }, - { - "b": { - "$in": "?array<?number>" - } - }, - { - "c": { - "$gt": "?number" - } - } - ] - })", - "{$or: [{a: 5}, {b: {$in: [1,2,3]}}, {c: {$gt: 10}}]}"); -} - -TEST(QueryPredicateShape, ElemMatch) { - // ElemMatchObjectMatchExpression - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({ - "a": { - "$elemMatch": { - "$and": [ - { - "b": { - "$eq": "?number" - } - }, - { - "c": { - "$exists": "?bool" - } - } - ] - } - } - })", - "{a: {$elemMatch: {b: 5, c: {$exists: true}}}}"); - - // ElemMatchValueMatchExpression - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"a":{"$elemMatch":{"$gt":"?number","$lt":"?number"}}})", - "{a: {$elemMatch: {$gt: 5, $lt: 10}}}"); - - // Nested - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({ - "HASH<a>": { - "$elemMatch": { - "$elemMatch": { - "$gt": "?number", - "$lt": "?number" - } - } - } - })", - "{a: {$elemMatch: {$elemMatch: {$gt: 5, $lt: 10}}}}"); -} - -TEST(QueryPredicateShape, InternalBucketGeoWithinMatchExpression) { - auto query = - "{ $_internalBucketGeoWithin: {withinRegion: {$centerSphere: [[0, 0], 10]}, field: " - "\"a\"} " - "}"; - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({ - "$_internalBucketGeoWithin": { - "withinRegion": { - "$centerSphere": "?array<>" - }, - "field": "HASH<a>" - } - })", - query); -} - -TEST(QueryPredicateShape, NorMatchExpression) { - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({"$nor":[{"HASH<a>":{"$lt":"?number"}},{"HASH<b>":{"$gt":"?number"}}]})", - "{ $nor: [ { a: {$lt: 5} }, { b: {$gt: 4} } ] }"); -} - -TEST(QueryPredicateShape, NotMatchExpression) { - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({"HASH<price>":{"$not":{"$gt":"?number"}}})", - "{ price: { $not: { $gt: 1.99 } } }"); - // Test the special case where NotMatchExpression::serialize() reduces to $alwaysFalse. - auto emptyAnd = std::make_unique<AndMatchExpression>(); - const MatchExpression& notExpr = NotMatchExpression(std::move(emptyAnd)); - auto serialized = - notExpr.serialize(SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({"$alwaysFalse":"?number"})", - serialized); -} - -TEST(QueryPredicateShape, SizeMatchExpression) { - ASSERT_REDACTED_SHAPE_EQ_AUTO( // NOLINT - R"({"HASH<price>":{"$size":"?number"}})", - "{ price: { $size: 2 } }"); -} - -TEST(QueryPredicateShape, TextMatchExpression) { - TextMatchExpressionBase::TextParams params = {"coffee"}; - auto expr = ExtensionsCallbackNoop().createText(params); - auto literalAndFieldRedactOpts = SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST; - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$text": { - "$search": "?string", - "$language": "?string", - "$caseSensitive": "?bool", - "$diacriticSensitive": "?bool" - } - })", - expr->serialize(SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST)); -} - -TEST(QueryPredicateShape, TwoDPtInAnnulusExpression) { - const MatchExpression& expr = TwoDPtInAnnulusExpression({}, {}); - auto literalAndFieldRedactOpts = SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST; - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({"$TwoDPtInAnnulusExpression":true})", - expr.serialize(SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST)); -} - -TEST(QueryPredicateShape, WhereMatchExpression) { - ASSERT_SHAPE_EQ_AUTO( // NOLINT - R"({"$where":"?javascript"})", - "{$where: \"some_code()\"}"); -} - -BSONObj queryShapeForOptimizedExprExpression(std::string exprPredicateJson) { - ParsedMatchExpressionForTest expr(exprPredicateJson); - // We need to optimize an $expr expression in order to generate an $_internalExprEq. It's - // not clear we'd want to do optimization before computing the query shape, but we should - // support the computation on any MatchExpression, and this is the easiest way we can create - // this type of MatchExpression node. - auto optimized = MatchExpression::optimize(expr.release()); - return predicateShape(optimized.get()); -} - -TEST(QueryPredicateShape, OptimizedExprPredicates) { - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$_internalExprEq": "?number" - } - }, - { - "$expr": { - "$eq": [ - "$a", - "?number" - ] - } - } - ] - })", - queryShapeForOptimizedExprExpression("{$expr: {$eq: ['$a', 2]}}")); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$_internalExprLt": "?number" - } - }, - { - "$expr": { - "$lt": [ - "$a", - "?number" - ] - } - } - ] - })", - queryShapeForOptimizedExprExpression("{$expr: {$lt: ['$a', 2]}}")); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$_internalExprLte": "?number" - } - }, - { - "$expr": { - "$lte": [ - "$a", - "?number" - ] - } - } - ] - })", - queryShapeForOptimizedExprExpression("{$expr: {$lte: ['$a', 2]}}")); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$_internalExprGt": "?number" - } - }, - { - "$expr": { - "$gt": [ - "$a", - "?number" - ] - } - } - ] - })", - queryShapeForOptimizedExprExpression("{$expr: {$gt: ['$a', 2]}}")); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "$and": [ - { - "a": { - "$_internalExprGte": "?number" - } - }, - { - "$expr": { - "$gte": [ - "$a", - "?number" - ] - } - } - ] - })", - queryShapeForOptimizedExprExpression("{$expr: {$gte: ['$a', 2]}}")); -} - -TEST(QueryShapeIDL, ShapifyIDLStruct) { - SerializationOptions options; - options.transformIdentifiers = true; - options.transformIdentifiersCallback = [](StringData s) -> std::string { - return str::stream() << "HASH<" << s << ">"; - }; - options.literalPolicy = LiteralSerializationPolicy::kToDebugTypeString; - - auto nested = NestedStruct("value", - ExampleEnumEnum::Value1, - "hello", - {1, 2, 3, 4}, - "field.path", - {"field.path.1", "fieldpath2"}, - NamespaceString{"db", "coll"}, - NamespaceString{"db", "coll"}, - 177, - true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "stringField": "value", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": [ - 1, - 2, - 3, - 4 - ], - "fieldpath": "field.path", - "fieldpathList": [ - "field.path.1", - "fieldpath2" - ], - "nss": "db.coll", - "plainNss": "db.coll", - "safeInt64Field": 177, - "boolField": true - })", - nested.toBSON()); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "stringField": "?string", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": "?array<?number>", - "fieldpath": "HASH<field>.HASH<path>", - "fieldpathList": [ - "HASH<field>.HASH<path>.HASH<1>", - "HASH<fieldpath2>" - ], - "nss": "HASH<db.coll>", - "plainNss": "db.coll", - "safeInt64Field": "?number", - "boolField": "?bool" - })", - nested.toBSON(options)); - - - auto parent = ParentStruct(nested, nested); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "nested_shape": { - "stringField": "value", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": [ - 1, - 2, - 3, - 4 - ], - "fieldpath": "field.path", - "fieldpathList": [ - "field.path.1", - "fieldpath2" - ], - "nss": "db.coll", - "plainNss": "db.coll", - "safeInt64Field": 177, - "boolField": true - }, - "nested_no_shape": { - "stringField": "value", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": [ - 1, - 2, - 3, - 4 - ], - "fieldpath": "field.path", - "fieldpathList": [ - "field.path.1", - "fieldpath2" - ], - "nss": "db.coll", - "plainNss": "db.coll", - "safeInt64Field": 177, - "boolField": true - } - })", - parent.toBSON()); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "nested_shape": { - "stringField": "?string", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": "?array<?number>", - "fieldpath": "HASH<field>.HASH<path>", - "fieldpathList": [ - "HASH<field>.HASH<path>.HASH<1>", - "HASH<fieldpath2>" - ], - "nss": "HASH<db.coll>", - "plainNss": "db.coll", - "safeInt64Field": "?number", - "boolField": "?bool" - }, - "nested_no_shape": { - "stringField": "value", - "enumField": "EnumValue1", - "stringIntVariantEnum": "hello", - "arrayOfInts": [ - 1, - 2, - 3, - 4 - ], - "fieldpath": "field.path", - "fieldpathList": [ - "field.path.1", - "fieldpath2" - ], - "nss": "db.coll", - "plainNss": "db.coll", - "safeInt64Field": 177, - "boolField": true - } - })", - parent.toBSON(options)); -} - -} // namespace - -namespace { - -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - -struct DummyShapeSpecificComponents : public query_shape::CmdSpecificShapeComponents { - DummyShapeSpecificComponents(){}; - void HashValue(absl::HashState state) const {} - size_t size() const final { - return sizeof(DummyShapeSpecificComponents); - } -}; - -class DummyShape : public Shape { -public: - DummyShape(NamespaceStringOrUUID nssOrUUID, - BSONObj collation, - DummyShapeSpecificComponents dummyComponents) - : Shape(nssOrUUID, collation) { - components = dummyComponents; - } - - const CmdSpecificShapeComponents& specificComponents() const final { - return components; - } - - void appendCmdSpecificShapeComponents(BSONObjBuilder&, - OperationContext*, - const SerializationOptions& opts) const final {} - DummyShapeSpecificComponents components; -}; - -class DummyShapeWithExtraSize : public Shape { -public: - DummyShapeWithExtraSize(NamespaceStringOrUUID nssOrUUID, - BSONObj collation, - DummyShapeSpecificComponents dummyComponents) - : Shape(nssOrUUID, collation) { - components = dummyComponents; - } - - const CmdSpecificShapeComponents& specificComponents() const final { - return components; - } - - // Random number for testing purposes. - size_t extraSize() const final override { - return 125; - } - void appendCmdSpecificShapeComponents(BSONObjBuilder&, - OperationContext*, - const SerializationOptions& opts) const final {} - - DummyShapeSpecificComponents components; -}; - -class UniversalShapeTest : public ServiceContextTest {}; - -TEST_F(UniversalShapeTest, SizeOfSpecificComponents) { - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - ASSERT_EQ(innerComponents->size(), sizeof(CmdSpecificShapeComponents)); - ASSERT_EQ(innerComponents->size(), sizeof(void*) /*vtable ptr*/); -} - -TEST_F(UniversalShapeTest, SizeOfShape) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - // Make shape for testing. - auto collation = BSONObj{}; - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - auto shape = std::make_unique<DummyShape>(kDefaultTestNss, collation, *innerComponents); - - ASSERT_EQ(innerComponents->size(), shape->specificComponents().size()); - ASSERT_EQ(shape->size(), - sizeof(NamespaceStringOrUUID) + sizeof(BSONObj) + sizeof(void*) /*vtable ptr*/ + - shape->specificComponents().size() + static_cast<size_t>(collation.objsize())); -} - -TEST_F(UniversalShapeTest, SizeOfShapeWithExtraSize) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - // Make shape for testing. - auto collation = BSONObj{}; - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - auto shape = std::make_unique<DummyShape>(kDefaultTestNss, collation, *innerComponents); - auto shapeWithExtraSize = - std::make_unique<DummyShapeWithExtraSize>(kDefaultTestNss, collation, *innerComponents); - - ASSERT_EQ(shapeWithExtraSize->size(), shape->size() + shapeWithExtraSize->extraSize()); -} -} // namespace -} // namespace mongo::query_shape diff --git a/src/mongo/db/query/query_shape/query_shape_test.idl b/src/mongo/db/query/query_shape/query_shape_test.idl deleted file mode 100644 index 06efb7ed1ef..00000000000 --- a/src/mongo/db/query/query_shape/query_shape_test.idl +++ /dev/null @@ -1,91 +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. -# - -global: - cpp_namespace: "mongo" - -imports: - - "mongo/idl/basic_types.idl" - -enums: - ExampleEnum: - description: "" - type: string - values: - Value1: "EnumValue1" - Value2: "EnumValue2" - -structs: - NestedStruct: - query_shape_component: true - strict: true - description: "" - fields: - stringField: - query_shape: literal - type: string - enumField: - query_shape: parameter - type: ExampleEnum - stringIntVariantEnum: - query_shape: parameter - type: - variant: [string, int] - arrayOfInts: - query_shape: literal - type: array<int> - fieldpath: - query_shape: anonymize - type: string - fieldpathList: - query_shape: anonymize - type: array<string> - nss: - query_shape: custom - type: namespacestring - plainNss: - query_shape: parameter - type: namespacestring - safeInt64Field: - query_shape: literal - type: safeInt64 - boolField: - query_shape: literal - type: bool - - ParentStruct: - query_shape_component: true - strict: true - description: "" - fields: - nested_shape: - query_shape: literal - type: NestedStruct - nested_no_shape: - query_shape: parameter - type: NestedStruct diff --git a/src/mongo/db/query/query_shape/serialization_options.cpp b/src/mongo/db/query/query_shape/serialization_options.cpp deleted file mode 100644 index e6008f8579b..00000000000 --- a/src/mongo/db/query/query_shape/serialization_options.cpp +++ /dev/null @@ -1,515 +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 "serialization_options.h" -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -#include "mongo/db/query/query_shape/serialization_options.h" - -#include <boost/optional.hpp> -#include <string> - -#include "mongo/base/string_data.h" -#include "mongo/bson/timestamp.h" -#include "mongo/db/exec/document_value/document.h" -#include "mongo/db/exec/document_value/value.h" -#include "mongo/db/query/explain_options.h" -#include "mongo/logv2/log.h" -#include "mongo/util/assert_util.h" - -namespace mongo { - -namespace { - -// We'll pre-declare all of these strings so that we can avoid the allocations when we reference -// them later. -static constexpr StringData kUndefinedTypeString = "?undefined"_sd; -static constexpr StringData kStringTypeString = "?string"_sd; -static constexpr StringData kNumberTypeString = "?number"_sd; -static constexpr StringData kMinKeyTypeString = "?minKey"_sd; -static constexpr StringData kObjectTypeString = "?object"_sd; -static constexpr StringData kArrayTypeString = "?array"_sd; -static constexpr StringData kBinDataTypeString = "?binData"_sd; -static constexpr StringData kObjectIdTypeString = "?objectId"_sd; -static constexpr StringData kBoolTypeString = "?bool"_sd; -static constexpr StringData kDateTypeString = "?date"_sd; -static constexpr StringData kNullTypeString = "?null"_sd; -static constexpr StringData kRegexTypeString = "?regex"_sd; -static constexpr StringData kDbPointerTypeString = "?dbPointer"_sd; -static constexpr StringData kJavascriptTypeString = "?javascript"_sd; -static constexpr StringData kJavascriptWithScopeTypeString = "?javascriptWithScope"_sd; -static constexpr StringData kTimestampTypeString = "?timestamp"_sd; -static constexpr StringData kMaxKeyTypeString = "?maxKey"_sd; - -static const StringMap<StringData> kArrayTypeStringConstants{ - {kUndefinedTypeString.rawData(), "?array<?undefined>"_sd}, - {kStringTypeString.rawData(), "?array<?string>"_sd}, - {kNumberTypeString.rawData(), "?array<?number>"_sd}, - {kMinKeyTypeString.rawData(), "?array<?minKey>"_sd}, - {kObjectTypeString.rawData(), "?array<?object>"_sd}, - {kArrayTypeString.rawData(), "?array<?array>"_sd}, - {kBinDataTypeString.rawData(), "?array<?binData>"_sd}, - {kObjectIdTypeString.rawData(), "?array<?objectId>"_sd}, - {kBoolTypeString.rawData(), "?array<?bool>"_sd}, - {kDateTypeString.rawData(), "?array<?date>"_sd}, - {kNullTypeString.rawData(), "?array<?null>"_sd}, - {kRegexTypeString.rawData(), "?array<?regex>"_sd}, - {kDbPointerTypeString.rawData(), "?array<?dbPointer>"_sd}, - {kJavascriptTypeString.rawData(), "?array<?javascript>"_sd}, - {kJavascriptWithScopeTypeString.rawData(), "?array<?javascriptWithScope>"_sd}, - {kTimestampTypeString.rawData(), "?array<?timestamp>"_sd}, - {kMaxKeyTypeString.rawData(), "?array<?maxKey>"_sd}, -}; - -static constexpr auto kRepresentativeString = "?"_sd; -static constexpr auto kRepresentativeNumber = 1; -static const auto kRepresentativeObject = BSON("?" - << "?"); -static const auto kRepresentativeArray = BSONArray(); -static constexpr auto kRepresentativeBinData = BSONBinData(); -static const auto kRepresentativeObjectId = OID::max(); -static constexpr auto kRepresentativeBool = true; -static const auto kRepresentativeDate = Date_t::fromMillisSinceEpoch(0); -static const auto kRepresentativeRegex = BSONRegEx("/\?/"); -static const auto kRepresentativeDbPointer = BSONDBRef("?.?", OID::max()); -static const auto kRepresentativeJavascript = BSONCode("return ?;"); -static const auto kRepresentativeJavascriptWithScope = BSONCodeWScope("return ?;", BSONObj()); -static const auto kRepresentativeTimestamp = Timestamp::min(); - -/** - * A default redaction strategy that generates easy to check results for testing purposes. - */ -std::string applyHmacForTest(StringData s) { - // Avoid ending in a parenthesis since the results will occur in a raw string where the )" - // sequence will accidentally terminate the string. - return str::stream() << "HASH<" << s << ">"; -} - -/** - * Computes a debug string meant to represent "any value of type t", where "t" is the type of the - * provided argument. For example "?number" for any number (int, double, etc.). - */ -StringData debugTypeString(BSONType t) { - // This is tightly coupled with 'canonicalizeBSONType' and therefore also with - // sorting/comparison semantics. - switch (t) { - case EOO: - case Undefined: - return kUndefinedTypeString; - case Symbol: - case String: - return kStringTypeString; - case NumberInt: - case NumberLong: - case NumberDouble: - case NumberDecimal: - return kNumberTypeString; - case MinKey: - return kMinKeyTypeString; - case Object: - return kObjectTypeString; - case Array: - // This case should only happen if we have an array within an array. - return kArrayTypeString; - case BinData: - return kBinDataTypeString; - case jstOID: - return kObjectIdTypeString; - case Bool: - return kBoolTypeString; - case Date: - return kDateTypeString; - case jstNULL: - return kNullTypeString; - case RegEx: - return kRegexTypeString; - case DBRef: - return kDbPointerTypeString; - case Code: - return kJavascriptTypeString; - case CodeWScope: - return kJavascriptWithScopeTypeString; - case bsonTimestamp: - return kTimestampTypeString; - case MaxKey: - return kMaxKeyTypeString; - default: - MONGO_UNREACHABLE_TASSERT(7539806); - } -} - -/** - * Returns an arbitrary value of the same type as the one given. For any number, this will be the - * number 1. For any boolean this will be true. - * TODO if you need a different value to make sure it will parse, you should not use this API. - */ -ImplicitValue defaultLiteralOfType(BSONType t) { - // This is tightly coupled with 'canonicalizeBSONType' and therefore also with - // sorting/comparison semantics. - switch (t) { - case EOO: - case Undefined: - return BSONUndefined; - case Symbol: - case String: - return kRepresentativeString; - case NumberInt: - case NumberLong: - case NumberDouble: - case NumberDecimal: - return kRepresentativeNumber; - case MinKey: - return MINKEY; - case Object: - return kRepresentativeObject; - case Array: - // This case should only happen if we have an array within an array. - return kRepresentativeArray; - case BinData: - return kRepresentativeBinData; - case jstOID: - return kRepresentativeObjectId; - case Bool: - return kRepresentativeBool; - case Date: - return kRepresentativeDate; - case jstNULL: - return BSONNULL; - case RegEx: - return kRepresentativeRegex; - case DBRef: - return kRepresentativeDbPointer; - case Code: - return kRepresentativeJavascript; - case CodeWScope: - return kRepresentativeJavascriptWithScope; - case bsonTimestamp: - return kRepresentativeTimestamp; - case MaxKey: - return MAXKEY; - default: - MONGO_UNREACHABLE_TASSERT(7539803); - } -} - -/** - * A struct representing the sub-type information for an array. - */ -struct ArraySubtypeInfo { - /** - * Whether the values of an array are all the same BSON type or not (mixed). - */ - enum class NTypes { kEmpty, kOneType, kMixed }; - ArraySubtypeInfo(NTypes nTypes_) : nTypes(nTypes_) {} - ArraySubtypeInfo(BSONType oneType) : nTypes(NTypes::kOneType), singleType(oneType) {} - - NTypes nTypes; - boost::optional<BSONType> singleType = boost::none; -}; - -template <typename ValueType> -using GetTypeFn = std::function<BSONType(ValueType)>; - -static GetTypeFn<BSONElement> getBSONElementType = [](const BSONElement& e) { return e.type(); }; -static GetTypeFn<Value> getValueType = [](const Value& v) { return v.getType(); }; - -/** - * Scans 'arrayOfValues' to see if all values are of the same type or not. Returns this info in a - * struct - see the struct definition for how it is represented. - * - * Templated algorithm to handle both iterators of BSONElements or iterators of Values. - * 'getTypeCallback' is provided to abstract away the different '.type()' vs '.getType()' APIs. - */ -template <typename ArrayType, typename ValueType> -ArraySubtypeInfo determineArraySubType(const ArrayType& arrayOfValues, - GetTypeFn<ValueType> getTypeCallback) { - boost::optional<BSONType> firstType = boost::none; - for (auto&& v : arrayOfValues) { - if (!firstType) { - firstType.emplace(getTypeCallback(v)); - } else if (*firstType != getTypeCallback(v)) { - return {ArraySubtypeInfo::NTypes::kMixed}; - } - } - return firstType ? ArraySubtypeInfo{*firstType} - : ArraySubtypeInfo{ArraySubtypeInfo::NTypes::kEmpty}; -} - -ArraySubtypeInfo determineArraySubType(const BSONObj& arrayAsObj) { - return determineArraySubType<BSONObj, BSONElement>(arrayAsObj, getBSONElementType); -} -ArraySubtypeInfo determineArraySubType(const std::vector<Value>& values) { - return determineArraySubType<std::vector<Value>, Value>(values, getValueType); -} - -template <typename ValueType> -StringData debugTypeString( - const ValueType& v, - GetTypeFn<ValueType> getTypeCallback, - std::function<ArraySubtypeInfo(ValueType)> determineArraySubTypeCallback) { - if (getTypeCallback(v) == BSONType::Array) { - // Iterating the array as .Obj(), as if it were a BSONObj (with field names '0', '1', etc.) - // is faster than converting the whole thing to an array which would force a copy. - auto typeInfo = determineArraySubTypeCallback(v); - switch (typeInfo.nTypes) { - case ArraySubtypeInfo::NTypes::kEmpty: - return "[]"_sd; - case ArraySubtypeInfo::NTypes::kOneType: - return kArrayTypeStringConstants.at(debugTypeString(*typeInfo.singleType)); - case ArraySubtypeInfo::NTypes::kMixed: - return "?array<>"; - default: - MONGO_UNREACHABLE_TASSERT(7539801); - } - } - return debugTypeString(getTypeCallback(v)); -} - -template <typename ValueType> -ImplicitValue defaultLiteralOfType( - const ValueType& v, - GetTypeFn<ValueType> getTypeCallback, - std::function<ArraySubtypeInfo(ValueType)> determineArraySubTypeCallback) { - if (getTypeCallback(v) == BSONType::Array) { - auto typeInfo = determineArraySubTypeCallback(v); - switch (typeInfo.nTypes) { - case ArraySubtypeInfo::NTypes::kEmpty: - return BSONArray(); - case ArraySubtypeInfo::NTypes::kOneType: - return std::vector<Value>{defaultLiteralOfType(*typeInfo.singleType)}; - case ArraySubtypeInfo::NTypes::kMixed: - // We don't care which types, we'll use a number and a string as the canonical - // mixed type array regardless. This is to ensure we don't get 2^N possibilities - // for mixed type scenarios - we wish to collapse all "mixed type" arrays to one - // canonical mix. The choice of int and string is mostly arbitrary - hopefully - // somewhat comprehensible at a glance. - return std::vector<Value>{Value(2), Value("or more types"_sd)}; - default: - MONGO_UNREACHABLE_TASSERT(7539805); - } - } - return defaultLiteralOfType(getTypeCallback(v)); -} - -ArraySubtypeInfo getSubTypeFromBSONElemArray(BSONElement arrayElem) { - // Iterating the array as .Obj(), as if it were a BSONObj (with field names '0', '1', etc.) - // is faster than converting the whole thing to an array which would force a copy. - return determineArraySubType(arrayElem.Obj()); -} -ArraySubtypeInfo getSubTypeFromValueArray(const Value& arrayVal) { - return determineArraySubType(arrayVal.getArray()); -} - -void appendDefaultOfNonArrayType(BSONObjBuilder* bob, StringData name, const BSONElement& e) { - switch (e.type()) { - case EOO: - case Undefined: - bob->appendUndefined(name); - return; - case Symbol: - case String: - bob->append(name, kRepresentativeString); - return; - case NumberInt: - case NumberLong: - case NumberDouble: - case NumberDecimal: - bob->append(name, kRepresentativeNumber); - return; - case MinKey: - bob->appendMinKey(name); - return; - case Object: - bob->append(name, kRepresentativeObject); - return; - case Array: - // This case is more complicated and callers should use a more generic helper. - MONGO_UNREACHABLE_TASSERT(8094100); - case BinData: - bob->append(name, kRepresentativeBinData); - return; - case jstOID: - bob->append(name, kRepresentativeObjectId); - return; - case Bool: - bob->append(name, kRepresentativeBool); - return; - case Date: - bob->append(name, kRepresentativeDate); - return; - case jstNULL: - bob->appendNull(name); - return; - case RegEx: - bob->append(name, kRepresentativeRegex); - return; - case DBRef: - bob->append(name, kRepresentativeDbPointer); - return; - case Code: - bob->append(name, kRepresentativeJavascript); - return; - case CodeWScope: - bob->append(name, kRepresentativeJavascriptWithScope); - return; - case bsonTimestamp: - bob->append(name, kRepresentativeTimestamp); - return; - case MaxKey: - bob->appendMaxKey(name); - return; - default: - MONGO_UNREACHABLE_TASSERT(8094101); - }; -} -} // namespace - -const SerializationOptions SerializationOptions::kRepresentativeQueryShapeSerializeOptions = - SerializationOptions{LiteralSerializationPolicy::kToRepresentativeParseableValue}; - -const SerializationOptions SerializationOptions::kDebugQueryShapeSerializeOptions = - SerializationOptions{LiteralSerializationPolicy::kToDebugTypeString}; - -SerializationOptions::SerializationOptions(LiteralSerializationPolicy policy) - : literalPolicy(policy) {} -SerializationOptions::SerializationOptions( - boost::optional<ExplainOptions::Verbosity> explainVerbosity) - : verbosity(explainVerbosity) {} - -SerializationOptions::SerializationOptions(LiteralSerializationPolicy policy, - bool transformIdentifiers, - TokenizeIdentifierFunc transformIdentifiersCallbackFn) - : literalPolicy(policy), - transformIdentifiers(transformIdentifiers), - transformIdentifiersCallback(transformIdentifiersCallbackFn) {} - -const SerializationOptions SerializationOptions::kMarkIdentifiers_FOR_TEST{ - LiteralSerializationPolicy::kUnchanged, true, applyHmacForTest}; - -const SerializationOptions SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST{ - LiteralSerializationPolicy::kToDebugTypeString, true, applyHmacForTest}; - -// Overloads for BSONElem and Value. -StringData debugTypeString(BSONElement e) { - return debugTypeString<BSONElement>(e, getBSONElementType, getSubTypeFromBSONElemArray); -} -StringData debugTypeString(const Value& v) { - return debugTypeString<Value>(v, getValueType, getSubTypeFromValueArray); -} - -// Overloads for BSONElem and Value. -ImplicitValue defaultLiteralOfType(const Value& v) { - return defaultLiteralOfType<Value>(v, getValueType, getSubTypeFromValueArray); -} -ImplicitValue defaultLiteralOfType(BSONElement e) { - return defaultLiteralOfType<BSONElement>(e, getBSONElementType, getSubTypeFromBSONElemArray); -} - -void SerializationOptions::appendLiteral(BSONObjBuilder* bob, const BSONElement& e) const { - appendLiteral(bob, e.fieldNameStringData(), e); -} -void SerializationOptions::appendLiteral(BSONObjBuilder* bob, - StringData name, - const BSONElement& e) const { - // The first two cases are particularly performance sensitive. We could answer everything here - // with the code inside the 'kToDebugTypeString' branch, but there are some relatively easy ways - // to accomplish the first two policy cases (in the common cases), so we'll special case those - // in order to avoid constructing a temporary Value. - switch (literalPolicy) { - case LiteralSerializationPolicy::kUnchanged: - bob->appendAs(e, name); - return; - case LiteralSerializationPolicy::kToRepresentativeParseableValue: { - if (e.type() != BSONType::Array) { - appendDefaultOfNonArrayType(bob, name, e); - return; - } - // If it's an array we'll default to the slow but general codepath below. - [[fallthrough]]; - } - case LiteralSerializationPolicy::kToDebugTypeString: { - // Performance isn't as sensitive here. - return serializeLiteral(e).addToBsonObj(bob, name); - } - default: - MONGO_UNREACHABLE_TASSERT(8094102); - } -} - -void SerializationOptions::appendLiteral(BSONObjBuilder* bob, - StringData fieldName, - const ImplicitValue& v, - const boost::optional<Value>& representativeValue) const { - serializeLiteral(v, representativeValue).addToBsonObj(bob, fieldName); -} - -Value SerializationOptions::serializeLiteral( - const BSONElement& e, const boost::optional<Value>& representativeValue) const { - switch (literalPolicy) { - case LiteralSerializationPolicy::kUnchanged: - return Value(e); - case LiteralSerializationPolicy::kToDebugTypeString: - return Value(debugTypeString(e)); - case LiteralSerializationPolicy::kToRepresentativeParseableValue: - return representativeValue.value_or(defaultLiteralOfType(e)); - default: - MONGO_UNREACHABLE_TASSERT(7539802); - } -} - -Value SerializationOptions::serializeLiteral( - const ImplicitValue& v, const boost::optional<Value>& representativeValue) const { - switch (literalPolicy) { - case LiteralSerializationPolicy::kUnchanged: - return v; - case LiteralSerializationPolicy::kToDebugTypeString: - return Value(debugTypeString(v)); - case LiteralSerializationPolicy::kToRepresentativeParseableValue: - return representativeValue.value_or(defaultLiteralOfType(v)); - default: - MONGO_UNREACHABLE_TASSERT(7539804); - } -} - -std::string SerializationOptions::serializeFieldPathFromString(StringData path) const { - if (transformIdentifiers) { - try { - return serializeFieldPath(FieldPath(path, false)); - } catch (DBException& ex) { - LOGV2_DEBUG(7549808, - 1, - "Failed to convert a path string to a FieldPath", - "pathString"_attr = path, - "failure"_attr = ex.toStatus()); - return serializeFieldPath("invalidFieldPathPlaceholder"); - } - } - return path.toString(); -} -} // namespace mongo diff --git a/src/mongo/db/query/query_shape/serialization_options.h b/src/mongo/db/query/query_shape/serialization_options.h deleted file mode 100644 index 226da7689d3..00000000000 --- a/src/mongo/db/query/query_shape/serialization_options.h +++ /dev/null @@ -1,236 +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. - */ - -#pragma once -#include "mongo/base/string_data.h" -#include "mongo/bson/bsonobj.h" -#include "mongo/bson/bsonobjbuilder.h" -#include "mongo/db/exec/document_value/document.h" -#include "mongo/db/exec/document_value/value.h" -#include "mongo/db/pipeline/field_path.h" -#include "mongo/db/query/explain_options.h" -#include "mongo/util/assert_util.h" -#include <boost/optional.hpp> -#include <string> - -namespace mongo { -namespace { -// Should never be called, throw to ensure we catch this in tests. -std::string defaultHmacStrategy(StringData s) { - MONGO_UNREACHABLE_TASSERT(7332410); -} -} // namespace - -/** - * A policy enum for how to serialize literal values. - */ -enum class LiteralSerializationPolicy { - // The default way to serialize. Just serialize whatever literals were given if they are still - // available, or whatever you parsed them to. This is expected to be able to parse again, since - // it worked the first time. - kUnchanged, - // Serialize any literal value as "?number" or similar. For example "?bool" for any boolean. Use - // 'debugTypeString()' helper. - kToDebugTypeString, - // Serialize any literal value to one canonical value of the given type, with the constraint - // that the chosen representative value should be parseable in this context. There are some - // default implementations that will usually work (e.g. using the number 1 almost always works - // for numbers), but serializers should be careful to think about and test this if their parsers - // reject certain values. - kToRepresentativeParseableValue, -}; - -/** - * A struct with options for how you want to serialize a match or aggregation expression. - */ -struct SerializationOptions { - using TokenizeIdentifierFunc = std::function<std::string(StringData)>; - - // The default serialization options for a query shape. No need to redact identifiers for the - // this purpose. We may do that on the $queryStats read path. - static const SerializationOptions kRepresentativeQueryShapeSerializeOptions; - static const SerializationOptions kDebugQueryShapeSerializeOptions; - static const SerializationOptions kMarkIdentifiers_FOR_TEST; - static const SerializationOptions kDebugShapeAndMarkIdentifiers_FOR_TEST; - - SerializationOptions() = default; - SerializationOptions(LiteralSerializationPolicy policy); - SerializationOptions(boost::optional<ExplainOptions::Verbosity> explain); - SerializationOptions(LiteralSerializationPolicy policy, - bool transformIdentifiers, - TokenizeIdentifierFunc transformIdentifiersCallbackFn); - - /** - * Checks if this SerializationOptions represents the same options as another - * SerializationOptions. Note it cannot compare whether the two 'transformIdentifiersCallback's - * are the same - the language purposefully leaves the comparison operator undefined. - */ - bool operator==(const SerializationOptions& other) const { - return this->transformIdentifiers == other.transformIdentifiers && - // You cannot well determine std::function equivalence in C++, so this is the best we'll - // do. - (this->transformIdentifiersCallback == nullptr) == - (other.transformIdentifiersCallback == nullptr) && - this->literalPolicy == other.literalPolicy && this->verbosity == other.verbosity; - } - bool operator!=(const SerializationOptions& other) const { - return !(*this == other); - } - - // Helper function for removing identifiable information (like collection/db names). - // Note: serializeFieldPath/serializeFieldPathFromString should be used for field - // names. - std::string serializeIdentifier(StringData str) const { - if (transformIdentifiers) { - return transformIdentifiersCallback(str); - } - return str.toString(); - } - - std::string serializeFieldPath(FieldPath path) const { - if (transformIdentifiers) { - std::stringstream hmaced; - for (size_t i = 0; i < path.getPathLength(); ++i) { - if (i > 0) { - hmaced << "."; - } - hmaced << transformIdentifiersCallback(path.getFieldName(i)); - } - return hmaced.str(); - } - return path.fullPath(); - } - - std::string serializeFieldPathWithPrefix(FieldPath path) const { - return "$" + serializeFieldPath(path); - } - - std::string serializeFieldPathFromString(StringData path) const; - - std::vector<std::string> serializeFieldPathFromString( - const std::vector<std::string>& paths) const { - std::vector<std::string> result; - result.reserve(paths.size()); - for (auto& p : paths) { - result.push_back(serializeFieldPathFromString(p)); - } - return result; - } - - // Helper functions for applying hmac to BSONObj. Does not take into account anything to do with - // MQL semantics, removes all field names and literals in the passed in obj. - void addHmacedArrayToBuilder(BSONArrayBuilder* bab, std::vector<BSONElement> array) const { - for (const auto& elem : array) { - if (elem.type() == BSONType::Object) { - BSONObjBuilder subObj(bab->subobjStart()); - addHmacedObjToBuilder(&subObj, elem.Obj()); - subObj.done(); - } else if (elem.type() == BSONType::Array) { - BSONArrayBuilder subArr(bab->subarrayStart()); - addHmacedArrayToBuilder(&subArr, elem.Array()); - subArr.done(); - } else { - *bab << serializeLiteral(elem); - } - } - } - - void addHmacedObjToBuilder(BSONObjBuilder* bob, BSONObj objToHmac) const { - for (const auto& elem : objToHmac) { - auto fieldName = serializeFieldPath(elem.fieldName()); - if (elem.type() == BSONType::Object) { - BSONObjBuilder subObj(bob->subobjStart(fieldName)); - addHmacedObjToBuilder(&subObj, elem.Obj()); - subObj.done(); - } else if (elem.type() == BSONType::Array) { - BSONArrayBuilder subArr(bob->subarrayStart(fieldName)); - addHmacedArrayToBuilder(&subArr, elem.Array()); - subArr.done(); - } else { - appendLiteral(bob, fieldName, elem); - } - } - } - - /** - * Helper method to call 'serializeLiteral()' on 'e' and append the resulting value to 'bob' - * using the same name as 'e'. - */ - void appendLiteral(BSONObjBuilder* bob, const BSONElement& e) const; - void appendLiteral(BSONObjBuilder* bob, StringData name, const BSONElement& e) const; - /** - * Helper method to call 'serializeLiteral()' on 'v' and append the result to 'bob' using field - * name 'fieldName'. - */ - void appendLiteral(BSONObjBuilder* bob, - StringData fieldName, - const ImplicitValue& v, - const boost::optional<Value>& representativeValue = boost::none) const; - - /** - * Depending on the configured 'literalPolicy', serializeLiteral will return the appropriate - * value for adding literals to serialization output: - * - If 'literalPolicy' is 'kUnchanged', returns the input value unmodified. - * - If it is 'kToDebugTypeString', computes and returns the type string as a string Value. - * - If it is 'kToRepresentativeValue', it returns an arbitrary value of the same type as the - * one given. For any number, this will be the number 1. For any boolean this will be true. - * If the 'representativeValue' parameter if it is not none, returns it (regardless of type). - * - * Example usage: BSON("myArg" << options.serializeLiteral(_myArg)); - */ - Value serializeLiteral(const BSONElement& e, - const boost::optional<Value>& representativeValue = boost::none) const; - Value serializeLiteral(const ImplicitValue& v, - const boost::optional<Value>& representativeValue = boost::none) const; - - // 'literalPolicy' is an independent option to serialize in a general format with the aim of - // similar "shaped" queries serializing to the same object. For example, if set to - // 'kToDebugTypeString', then the serialization of {a: {$gt: 2}} should result in {a: {$gt: - // '?number'}}, as will the serialization of {a: {$gt: 3}}. - // - // "Literal" here is meant to stand in contrast to expression arguments, as in the $gt - // expressions in {$and: [{a: {$gt: 3}}, {b: {$gt: 4}}]}. There the only literals are 3 and 4, - // so the serialization expected for 'kToDebugTypeString' would be {$and: [{a: {$gt: - // '?number'}}, {b: {$lt: '?number'}}]}. - LiteralSerializationPolicy literalPolicy = LiteralSerializationPolicy::kUnchanged; - - // If true the caller must set transformIdentifiersCallback. 'transformIdentifiers' if set along - // with a strategy the redaction strategy will be called on any personal identifiable - // information (e.g., field paths/names, collection names) encountered before serializing them. - bool transformIdentifiers = false; - std::function<std::string(StringData)> transformIdentifiersCallback = defaultHmacStrategy; - - // For aggregation indicate whether we should use the more verbose serialization format. - boost::optional<ExplainOptions::Verbosity> verbosity = boost::none; - - // If set to true, serializes each stage and expression as needed for query analysis. - bool serializeForQueryAnalysis = false; -}; - -} // namespace mongo diff --git a/src/mongo/db/query/query_shape/shape_helpers.cpp b/src/mongo/db/query/query_shape/shape_helpers.cpp deleted file mode 100644 index 8eea475ab78..00000000000 --- a/src/mongo/db/query/query_shape/shape_helpers.cpp +++ /dev/null @@ -1,108 +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 "mongo/db/query/query_shape/shape_helpers.h" - -#include "mongo/db/query/query_shape/query_shape_gen.h" - -namespace mongo::shape_helpers { - -static constexpr StringData hintSpecialField = "$hint"_sd; -// A "Flat" object is one with only top-level fields. We won't descend recursively to shapify any -// sub-objects. -BSONObj shapifyFlatObj(BSONObj obj, const SerializationOptions& opts, bool valuesAreLiterals) { - if (obj.isEmpty()) { - // fast-path for the common case. - return obj; - } - - BSONObjBuilder bob; - for (BSONElement elem : obj) { - if (hintSpecialField.compare(elem.fieldNameStringData()) == 0) { - if (elem.type() == BSONType::String) { - bob.append(hintSpecialField, opts.serializeFieldPathFromString(elem.String())); - } else if (elem.type() == BSONType::Object) { - opts.appendLiteral(&bob, hintSpecialField, elem.Obj()); - } else { - // SERVER-85500: $hint syntax will not be validated if the collection does not - // exist, so we should accept a value that is neither string nor object here. - opts.appendLiteral(&bob, hintSpecialField, elem); - } - continue; - } - - // $natural doesn't need to be redacted. - if (elem.fieldNameStringData().compare(query_request_helper::kNaturalSortField) == 0) { - bob.append(elem); - continue; - } - - if (valuesAreLiterals) { - opts.appendLiteral(&bob, opts.serializeFieldPathFromString(elem.fieldName()), elem); - } else { - bob.appendAs(elem, opts.serializeFieldPathFromString(elem.fieldName())); - } - } - return bob.obj(); -} - -BSONObj extractHintShape(BSONObj hintObj, const SerializationOptions& opts) { - return shapifyFlatObj(hintObj, opts, /* valuesAreLiterals = */ false); -} - -BSONObj extractMinOrMaxShape(BSONObj obj, const SerializationOptions& opts) { - return shapifyFlatObj(obj, opts, /* valuesAreLiterals = */ true); -} - -void appendNamespaceShape(BSONObjBuilder& bob, - const NamespaceString& nss, - const SerializationOptions& opts) { - bob.append("db", opts.serializeIdentifier(nss.db())); - bob.append("coll", opts.serializeIdentifier(nss.coll())); -} - -NamespaceStringOrUUID parseNamespaceShape(BSONElement cmdNsElt) { - tassert(7632900, "cmdNs must be an object.", cmdNsElt.type() == BSONType::Object); - auto cmdNs = query_shape::CommandNamespace::parse("cmdNs"_sd, cmdNsElt.embeddedObject()); - - if (cmdNs.getColl().has_value()) { - tassert(7632903, - "Exactly one of 'uuid' and 'coll' can be defined.", - !cmdNs.getUuid().has_value()); - return NamespaceString(cmdNs.getDb(), cmdNs.getColl().value()); - } else { - tassert(7632904, - "Exactly one of 'uuid' and 'coll' can be defined.", - !cmdNs.getColl().has_value()); - UUID uuid = uassertStatusOK(UUID::parse(cmdNs.getUuid().value().toString())); - return NamespaceStringOrUUID(cmdNs.getDb().toString(), uuid); - } -} - -} // namespace mongo::shape_helpers diff --git a/src/mongo/db/query/query_shape/shape_helpers.h b/src/mongo/db/query/query_shape/shape_helpers.h deleted file mode 100644 index 4d0fadb4a47..00000000000 --- a/src/mongo/db/query/query_shape/shape_helpers.h +++ /dev/null @@ -1,101 +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. - */ - -#pragma once - -#include "mongo/bson/simple_bsonobj_comparator.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/serialization_options.h" - -namespace mongo::shape_helpers { - -int64_t inline optionalObjSize(boost::optional<BSONObj> optionalObj) { - if (!optionalObj) - return 0; - return optionalObj->objsize(); -} - -template <typename T> -int64_t optionalSize(boost::optional<T> optionalVal) { - if (!optionalVal) - return 0; - return optionalVal->size(); -} - -template <typename T> -std::function<size_t(size_t, const T&)> sizeAccumulatorFunc() { - MONGO_UNREACHABLE; // Don't know how to compute the size of this template type. -}; - -template <> -inline std::function<size_t(size_t, const BSONObj&)> sizeAccumulatorFunc<BSONObj>() { - return [](size_t total, const BSONObj& obj) { - return total + sizeof(BSONObj) + static_cast<size_t>(obj.objsize()); - }; -} - -template <> -inline std::function<size_t(size_t, const NamespaceString&)> -sizeAccumulatorFunc<NamespaceString>() { - return [](size_t total, const NamespaceString& nss) { - // For each element, we have to track the size of the - // nss as well as the size allocated by the nss. It would be - // ideal to be able to ask the underlying namespace string for - // its capacity, but it's not something we have access to. - // Further, namespace strings appear to shrink to fit (i.e - // resize to correct size), so it may not be necessary. Should - // we also try to consider short string optimization? At the - // very least, the current approach gives us a good upper bound - // memory usage (assuming shrink to fit). - return total + sizeof(nss) + nss.size(); - }; -} - -template <typename Container> -size_t containerSize(const Container& container) { - return std::accumulate(container.begin(), - container.end(), - 0, - sizeAccumulatorFunc<typename Container::value_type>()); -} - -/** - * Serializes the given 'hintObj' in accordance with the options. Assumes the hint is correct and - * contains field names. It is possible that this hint doesn't actually represent an index, but we - * can't detect that here. - */ -BSONObj extractHintShape(BSONObj hintObj, const SerializationOptions& opts); -BSONObj extractMinOrMaxShape(BSONObj obj, const SerializationOptions& opts); - -NamespaceStringOrUUID parseNamespaceShape(BSONElement cmdNsElt); -void appendNamespaceShape(BSONObjBuilder& bob, - const NamespaceString& nss, - const SerializationOptions& opts); - -} // namespace mongo::shape_helpers diff --git a/src/mongo/db/query/query_solution.cpp b/src/mongo/db/query/query_solution.cpp index 191218b2f4d..dc24bc3653a 100644 --- a/src/mongo/db/query/query_solution.cpp +++ b/src/mongo/db/query/query_solution.cpp @@ -316,11 +316,7 @@ void CollectionScanNode::computeProperties() { void CollectionScanNode::appendToString(str::stream* ss, int indent) const { addIndent(ss, indent); - if (doClusteredCollectionScan()) { - *ss << "CLUSTERED_IDXSCAN\n"; - } else { - *ss << "COLLSCAN\n"; - } + *ss << "COLLSCAN\n"; addIndent(ss, indent + 1); *ss << "ns = " << name << '\n'; if (nullptr != filter) { @@ -337,9 +333,6 @@ QuerySolutionNode* CollectionScanNode::clone() const { copy->name = this->name; copy->tailable = this->tailable; copy->direction = this->direction; - copy->minRecord = this->minRecord; - copy->maxRecord = this->maxRecord; - copy->clusteredIndex = this->clusteredIndex; copy->shouldTrackLatestOplogTimestamp = this->shouldTrackLatestOplogTimestamp; copy->assertTsHasNotFallenOffOplog = this->assertTsHasNotFallenOffOplog; copy->shouldWaitForOplogVisibility = this->shouldWaitForOplogVisibility; @@ -1090,8 +1083,8 @@ bool IndexScanNode::operator==(const IndexScanNode& other) const { // ColumnIndexScanNode // ColumnIndexScanNode::ColumnIndexScanNode(ColumnIndexEntry indexEntry, - OrderedPathSet outputFieldsIn, - OrderedPathSet matchFieldsIn, + std::set<std::string> outputFieldsIn, + std::set<std::string> matchFieldsIn, StringMap<std::unique_ptr<MatchExpression>> filtersByPath, std::unique_ptr<MatchExpression> postAssemblyFilter) : indexEntry(std::move(indexEntry)), @@ -1566,11 +1559,11 @@ void GroupNode::appendToString(str::stream* ss, int indent) const { if (idx > 0) { *ss << ", "; } - *ss << "{" << groupName << ": " << exprObj->serialize().toString() << "}"; + *ss << "{" << groupName << ": " << exprObj->serialize(false).toString() << "}"; ++idx; } } else { - *ss << "{_id: " << groupByExpression->serialize().toString() << "}"; + *ss << "{_id: " << groupByExpression->serialize(false).toString() << "}"; } *ss << '\n'; addIndent(ss, indent + 1); @@ -1581,11 +1574,7 @@ void GroupNode::appendToString(str::stream* ss, int indent) const { } auto& acc = accumulators[idx]; *ss << "{" << acc.fieldName << ": {" << acc.expr.name << ": " - << acc.expr.argument - ->serialize(SerializationOptions{ - boost::make_optional(ExplainOptions::Verbosity::kQueryPlanner)}) - .toString() - << "}}"; + << acc.expr.argument->serialize(true).toString() << "}}"; } *ss << "]" << '\n'; addCommon(ss, indent); diff --git a/src/mongo/db/query/query_solution.h b/src/mongo/db/query/query_solution.h index 8b04e9f0bf3..f318884280b 100644 --- a/src/mongo/db/query/query_solution.h +++ b/src/mongo/db/query/query_solution.h @@ -463,10 +463,6 @@ struct CollectionScanNode : public QuerySolutionNodeWithSortSet { QuerySolutionNode* clone() const; - bool doClusteredCollectionScan() const { - return (!isOplog && (minRecord || maxRecord)); - } - // Name of the namespace. std::string name; @@ -506,9 +502,6 @@ struct CollectionScanNode : public QuerySolutionNodeWithSortSet { int direction{1}; - // Tells whether the collection is an oplog. - bool isOplog = false; - // By default, includes the minRecord and maxRecord when present. CollectionScanParams::ScanBoundInclusion boundInclusion = CollectionScanParams::ScanBoundInclusion::kIncludeBothStartAndEndRecords; @@ -522,8 +515,8 @@ struct CollectionScanNode : public QuerySolutionNodeWithSortSet { struct ColumnIndexScanNode : public QuerySolutionNode { ColumnIndexScanNode(ColumnIndexEntry, - OrderedPathSet outputFields, - OrderedPathSet matchFields, + std::set<std::string> outputFields, + std::set<std::string> matchFields, StringMap<std::unique_ptr<MatchExpression>> filtersByPath, std::unique_ptr<MatchExpression> postAssemblyFilter); @@ -563,11 +556,11 @@ struct ColumnIndexScanNode : public QuerySolutionNode { ColumnIndexEntry indexEntry; // The fields we need to output. Dot separated path names. - OrderedPathSet outputFields; + std::set<std::string> outputFields; // The fields which are referenced by any and all filters - either in 'filtersByPath' or // 'postAssemblyFilter'. - OrderedPathSet matchFields; + std::set<std::string> matchFields; // A column scan can apply a filter to the columns directly while scanning, or to a document // assembled from the scanned columns. @@ -582,7 +575,7 @@ struct ColumnIndexScanNode : public QuerySolutionNode { // A cached copy of the union of the above two field sets which we expect to be frequently asked // for. - OrderedPathSet allFields; + std::set<std::string> allFields; }; /** @@ -1401,13 +1394,11 @@ struct GroupNode : public QuerySolutionNode { for (auto& groupByExprField : groupByExpression->getDependencies().fields) { requiredFields.insert(groupByExprField); } - needWholeDocument = groupByExpression->getDependencies().needWholeDocument; for (auto&& acc : accumulators) { auto argExpr = acc.expr.argument; for (auto& argExprField : argExpr->getDependencies().fields) { requiredFields.insert(argExprField); } - needWholeDocument |= argExpr->getDependencies().needWholeDocument; } } @@ -1443,7 +1434,6 @@ struct GroupNode : public QuerySolutionNode { // the fields in the 'groupByExpressions' and the fields in the input Expressions of the // 'accumulators'. StringSet requiredFields; - bool needWholeDocument = false; // If set to true, generated SBE plan will produce result as BSON object. If false, // 'sbe::Object' is produced instead. diff --git a/src/mongo/db/query/query_stats/README.md b/src/mongo/db/query/query_stats/README.md deleted file mode 100644 index 6f2667fbfd9..00000000000 --- a/src/mongo/db/query/query_stats/README.md +++ /dev/null @@ -1,200 +0,0 @@ -# Query Stats -This directory is the home of the infrastructure related to recording runtime query statistics for -the database. It is not to be confused with `src/mongo/db/query/stats/` which is the home of the -logic for computing and maintaining statistics about a collection or index's data distribution - for -use by the query planner. - -The system will collect metrics for each query execution, and the results will be aggregated in a -structure called the [`QueryStatsStore`](#querystatsstore) upon completion of each successful -execution. Metrics will be aggregated according to an abstracted version of the query known as the -query stats key and will be collected on any mongod or mongos process for which they are configured, -including primaries and secondaries. - -## QueryStatsStore -At the center of everything here is the [`QueryStatsStore`](query_stats.h#93-97), which is a -partitioned hash table that maps the hash of a [Query Stats Key](#glossary) (also known as the -_Query Stats Store Key_) to some metrics about how often each one occurs. - -### Computing the Query Stats Store Key -A query stats store key contains various dimensions that distinctify a specific query. One main -attribute to the query stats store key, is the query shape (`query_shape::Shape`). For example, if -the client does this: -```js -db.example.findOne({x: 24}); -db.example.findOne({x: 53}); -``` -then the `QueryStatsStore` should contain an entry for a single query shape which would record 2 -executions and some related statistics (see [`QueryStatsEntry`](query_stats_entry.h) for details). - -For more information on query shape, see the [query_shape](../query_shape/README.md) directory. - -The query stats store has _more_ dimensions (i.e. more granularity) to group incoming queries than -just the query shape. For example, these queries would all three have the same shape but the first -would have a different query stats store entry from the other two: -```js -db.example.find({x: 55}); -db.example.find({x: 55}).batchSize(2); -db.example.find({x: 55}).batchSize(3); -``` -There are two distinct query stats store entries here - both the examples which include the batch -size will be treated separately from the example which does not specify a batch size. - -The dimensions considered will depend on the command, but can generally be found in the -[`KeyGenerator`](key_generator.h) interface, which will generate the query stats store keys by which -we accumulate statistics. As one example, you can find the -[`FindKey`](find_key.h) which will include all the things tracked in the -`FindCmdQueryStatsStoreKeyComponents` (including `batchSize` shown in this example). - -### Query Stats Store Cache Size -The size of the`QueryStatsStore` can be set by the server parameter -[`internalQueryStatsCacheSize`](#server-parameters), and the partitions will be created based off -that. See [`queryStatsStoreManagerRegisterer`](query_stats.cpp#L138-L154) for more details about how -the number of partitions and their size is determined; Each partition is an LRU cache, therefore, if -adding a new entry to the partition makes it go over its size limit, the least recently used entries -will be evicted to drop below the max size. Eviction will be tracked in the new [server status -metrics](#server-status-metrics) for queryStats. - -## Metric Collection -At a high level, when a query is run and collection of query stats is enabled, during planning we -call [`registerRequest`]((query_stats.h#L195-L198)) in which the query stats store key will be -generated based on the query's shape and the various other dimensions. The key will always be serialized -and stored on the `opDebug`, and also on the cursor in the case that there are `getMore`s, so that we can -continue to aggregate the operation's metrics. Once the query execution is fully complete, -[`writeQueryStats`](query_stats.h#L200-216) will be called and will either retrieve the entry for -the key from the store if it exists and update it, or create a new one and add it to the store. See -more details in the [comments](query_stats.h#L158-L216). - -### Rate Limiting -Whether or not query stats will be recorded for a specific query execution depends on a Rate -Limiter, which limits the number of recordings per second based on the server parameter -[internalQueryStatsRateLimit](#server-parameters). The goal of the rate limiter is to minimize -impact to overall system performance through restricting excessive traffic. If a query is run but -the rate limit has been reached, the query will still execute as expected but query stats will not -be updated in the query stats store. Our rate limiter uses the sliding window algorithm; see details -[here](rate_limiting.h#82-87). - -## Metric Retrieval -To retrieve the stats gathered in the `QueryStatsStore`, there is a new aggregation stage, -`$queryStats`. This stage must be the first in a pipeline and it must be run against the admin -database. The structure of the command is as follows (note `aggregate: 1` reflecting there is no collection): -```js -db.adminCommand({ - aggregate: 1, - pipeline: [{ - $queryStats: { - tranformIdentifiers: { - algorithm: "hmac-sha-256", - hmacKey: BinData(8, "87c4082f169d3fef0eef34dc8e23458cbb457c3sf3n2") /* bindata - subtype 8 - a new type for sensitive data */, - } - } - }] -}) -``` -`transformIdentifiers` is optional. If not present, we will generate the regular Query Stats Key. If -present: -- `algorithm` is required and the only currently supported option is "hmac-sha-256". -- `hmacKey` is required -- We will generate the [One-way Tokenized](#glossary) Query Stats Key by applying the "hmac-sha-256" - to the names of any field, collection, or database. Application Name field is not transformed. - -The query stats store will output one document for each query stats key, which is structured in the -following way: -```js -{ - key: {/* Query Stats Key */}, - asOf: ISODate(/* … */), - metrics: { - execCount: 0, - firstSeenTimestamp: ISODate(/* … */), - latestSeenTimestamp: ISODate(/* … */), - docsReturned: {sum: 0, max: 0, min: 0, sumOfSquares: 0}, - firstResponseExecMicros: {sum: 0, max: 0, min: 0, sumOfSquares: 0}, - totalExecMicros: {sum: 0, max: 0, min: 0, sumOfSquares: 0}, - lastExecutionMicros: 0, - } -} -``` -- `key`: Query Stats Key. -- `asOf`: UTC time when $queryStats read this entry from the store. This will not return the same - UTC time for each result. The data structure used for the store is partitioned, and each partition - will be read at a snapshot individually. You may see up to the number of partitions in unique - timestamps returned by one $queryStats cursor. -- `metrics`: the metrics collected; these may be flawed due to: - - Server restarts, which will reset metrics. - - LRU eviction, which will reset metrics. - - Rate limiting, which will skew metrics. -- `metrics.execCount`: Number of recorded observations of this query. -- `metrics.firstSeenTimestamp`: UTC time taken at query completion (including getMores) for the - first recording of this query stats store entry. -- `metrics.lastSeenTimestamp`: UTC time taken at query completion (including getMores) for the - latest recording of this query stats store entry. -- `metrics.docsReturned`: Various broken down metrics for the number of documents returned by - observation of this query. -- `metrics.firstResponseExecMicros`: Estimated time spent computing and returning the first batch. -- `metrics.totalExecMicros`: Estimated time spent computing and returning all batches, which is the - same as the above for single-batch queries. -- `metrics.lastExecutionMicros`: Estimated time spent processing the latest query (akin to - "totalExecMicros", not "firstResponseExecMicros"). - -#### Permissions -`$queryStats` is restricted by two privilege actions: -- `queryStatsRead` privilege allows running `$queryStats` without passing the `transformIdentifiers` - options. -- `queryStatsReadTransformed` allows running `$queryStats` with `transformIdentifiers` set. These -two privileges are included in the clusterMonitor role in Atlas. - -### Server Parameters -- `internalQueryStatsCacheSize`: - * Max query stats store size, specified as a string like "4MB" or "1%". Defaults to 1% of the - machine's total memory. - * Query stats store is a LRU cache structure with partitions, so we may be under the cap due to - implementation. - -- `internalQueryStatsRateLimit`: - * The rate limit is an integer which imposes a maximum number of recordings per second. Default is - 0 which has the effect of disabling query stats collection. Setting the parameter to -1 means - there will be no rate limit. - -- `logComponentVerbosity.queryStats`: - * Controls the logging behavior for query stats. See [Logging](#logging) for details. - -### Logging -Setting `logComponentVerbosity.queryStats` will do the following for each level: -* Level 0 (default): Nothing will be logged. -* Level 1 or higher: Invocations of $queryStats will be logged if and only if the algorithm is - "hmac-sha-256". The specification of the $queryStats stage is logged, with any provided hmac key - redacted. -* Level 2 or higher: Nothing extra, reserved for future use. -* Level 3 or higher: All results of any "hmac-sha-256" $queryStats invocation are logged. Each - result will be its own entry and there will be one final entry that says "we finished". -* Levels 4 and 5 do nothing extra. - -### Server Status Metrics -The following will be added to the `serverStatus.metrics`: -```js -queryStats: { - numEvicted: NumberLong(0), - numHmacApplicationErrors: NumberLong(0), - numQueryStatsStoreWriteErrors: NumberLong(0), - numRateLimitedRequests: NumberLong(0), - queryStatsStoreSizeEstimateBytes: NumberLong(0) -} -``` - -# Glossary -**Query Execution**: This term implies the overall execution of what a client would consider one -query, but which may or may not involve one or more getMore commands to iterate a cursor. For -example, a find command and two getMore commands on the returned cursor is one query execution. An -aggregate command which returns everything in one batch is also one query execution. - -**One-way Tokenized Object**: A one-way tokenized object has an HMAC hashing function applied to -particular sensitive elements/pieces of an object. It is "one-way" because it is never meant to be -undone. This allows us to detect when two queries are using the same identifiers, but never to -reveal what those identifiers were. - -**Query Shape**: [Query Shape](../query_shape/README.md) - -**Query Stats Key**: Also known as the _Query Stats Store Key_, this is the collection of attributes -championed by the query shape which identifies one grouping of metrics. The $queryStats stage will -output one document per query stats key - output in the "key" field. diff --git a/src/mongo/db/query/query_stats/SConscript b/src/mongo/db/query/query_stats/SConscript deleted file mode 100644 index f9f3a8b1c2e..00000000000 --- a/src/mongo/db/query/query_stats/SConscript +++ /dev/null @@ -1,121 +0,0 @@ -# -*- mode: python -*- - -Import([ - "env", - "get_option", -]) - -env = env.Clone() - -env.Library( - target='rate_limiting', - source=[ - 'rate_limiting.cpp', - ], - LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/util/clock_sources', - ], -) - -env.Library(target='query_stats_parse', source=['transform_algorithm.idl'], LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/idl/idl_parser', -]) - -env.Library( - target='query_stats', - source=[ - '$BUILD_DIR/mongo/db/curop.cpp', - 'key.cpp', - 'query_stats.cpp', - 'query_stats_entry.cpp' - ], - LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/bson/mutable/mutable_bson', - '$BUILD_DIR/mongo/db/commands', - '$BUILD_DIR/mongo/db/concurrency/lock_manager', - '$BUILD_DIR/mongo/db/exec/document_value/document_value', - '$BUILD_DIR/mongo/db/generic_cursor', - '$BUILD_DIR/mongo/db/profile_filter', - '$BUILD_DIR/mongo/db/query/command_request_response', - '$BUILD_DIR/mongo/db/query/memory_util', - '$BUILD_DIR/mongo/db/query/query_knobs', - '$BUILD_DIR/mongo/db/query/query_shape/query_shape', - '$BUILD_DIR/mongo/db/server_options', - '$BUILD_DIR/mongo/db/service_context', - '$BUILD_DIR/mongo/db/stats/counters', - '$BUILD_DIR/mongo/db/stats/timer_stats', - '$BUILD_DIR/mongo/db/storage/storage_engine_parameters', - '$BUILD_DIR/mongo/rpc/client_metadata', - '$BUILD_DIR/mongo/transport/service_executor', - '$BUILD_DIR/mongo/util/diagnostic_info' if get_option('use-diagnostic-latches') == 'on' else [], - '$BUILD_DIR/mongo/util/fail_point', - '$BUILD_DIR/mongo/util/net/network', - '$BUILD_DIR/mongo/util/processinfo', - '$BUILD_DIR/mongo/util/progress_meter', - 'query_stats_parse', - 'rate_limiting', - ], - LIBDEPS_PRIVATE=[ - '$BUILD_DIR/mongo/db/auth/auth', - '$BUILD_DIR/mongo/db/auth/user_acquisition_stats', - '$BUILD_DIR/mongo/db/exec/projection_executor', - '$BUILD_DIR/mongo/db/prepare_conflict_tracker', - '$BUILD_DIR/mongo/db/stats/resource_consumption_metrics', - ], -) - -env.CppUnitTest( - target="db_query_query_stats_test", - source=[ - "agg_key_test.cpp", - "find_key_test.cpp", - "key_test.cpp", - "query_stats_test.cpp", - "query_stats_store_test.cpp", - "rate_limiting_test.cpp", - ], - LIBDEPS=[ - "$BUILD_DIR/mongo/db/auth/authmocks", - "$BUILD_DIR/mongo/db/query/query_shape/query_shape", - "$BUILD_DIR/mongo/db/query/query_test_service_context", - "$BUILD_DIR/mongo/db/service_context_d_test_fixture", - "query_stats", - "rate_limiting", - ], -) - -env.Benchmark( - target='rate_limiting_bm', - source=[ - 'rate_limiting_bm.cpp', - ], - LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/unittest/unittest', - '$BUILD_DIR/mongo/util/processinfo', - 'rate_limiting', - ], -) - -env.Benchmark( - target='shapifying_bm', - source=[ - 'shapifying_bm.cpp', - ], - LIBDEPS=[ - '$BUILD_DIR/mongo/base', - '$BUILD_DIR/mongo/db/auth/auth', - '$BUILD_DIR/mongo/db/pipeline/pipeline', - '$BUILD_DIR/mongo/db/query/canonical_query', - '$BUILD_DIR/mongo/db/query/query_shape/query_shape', - '$BUILD_DIR/mongo/db/query/query_test_service_context', - '$BUILD_DIR/mongo/db/service_context', - '$BUILD_DIR/mongo/rpc/client_metadata', - '$BUILD_DIR/mongo/unittest/unittest', - '$BUILD_DIR/mongo/util/processinfo', - 'query_stats', - ], -) diff --git a/src/mongo/db/query/query_stats/agg_key.cpp b/src/mongo/db/query/query_stats/agg_key.cpp deleted file mode 100644 index 1d53418d371..00000000000 --- a/src/mongo/db/query/query_stats/agg_key.cpp +++ /dev/null @@ -1,174 +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 "mongo/db/query/query_stats/agg_key.h" - -#include "mongo/db/query/explain_options.h" -#include <absl/container/node_hash_set.h> -#include <boost/cstdint.hpp> -#include <functional> -#include <initializer_list> -#include <memory> -#include <numeric> -#include <vector> - -#include <boost/move/utility_core.hpp> -#include <boost/optional/optional.hpp> -#include <boost/smart_ptr/intrusive_ptr.hpp> - -#include "mongo/crypto/fle_field_schema_gen.h" -#include "mongo/db/pipeline/exchange_spec_gen.h" -#include "mongo/db/pipeline/pipeline.h" -#include "mongo/db/query/query_shape/agg_cmd_shape.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/db/query/query_shape/shape_helpers.h" -#include "mongo/idl/basic_types_gen.h" -#include "mongo/util/assert_util.h" - -namespace mongo::query_stats { - -AggCmdComponents::AggCmdComponents(const AggregateCommandRequest& request_, - stdx::unordered_set<NamespaceString> involvedNamespaces_) - : involvedNamespaces(std::move(involvedNamespaces_)), - _bypassDocumentValidation(request_.getBypassDocumentValidation().value_or(false)), - _verbosity(request_.getExplain()), - _hasField() { - _hasField.batchSize = request_.getCursor().getBatchSize().has_value(); - _hasField.bypassDocumentValidation = request_.getBypassDocumentValidation().has_value(); - _hasField.explain = request_.getExplain().has_value(); - _hasField.passthroughToShard = request_.getPassthroughToShard().has_value(); -} - - -void AggCmdComponents::HashValue(absl::HashState state) const { - // The hashing for verbosity in this branch needed to be different because the compiler was - // complaining about the different wrappers. This is not important since this computation is - // only used locally in memory on a single machine, and the query shape is still stable. - auto verbosity = - _hasField.explain ? std::string(ExplainOptions::verbosityString(_verbosity.value())) : ""; - state = absl::HashState::combine(std::move(state), - _bypassDocumentValidation, - _hasField.batchSize, - _hasField.bypassDocumentValidation, - verbosity, - _hasField.explain, - _hasField.passthroughToShard); - // We don't need to add 'involvedNamespaces' here since they are already tracked/duplicated in - // the Pipeline component of the query shape. We just expose them here for ease of - // analysis/querying. -} - -void AggCmdComponents::appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const { - - // otherNss - if (!involvedNamespaces.empty()) { - BSONArrayBuilder otherNss = bob.subarrayStart(kOtherNssFieldName); - for (const auto& nss : involvedNamespaces) { - BSONObjBuilder otherNsEntryBob = otherNss.subobjStart(); - shape_helpers::appendNamespaceShape(otherNsEntryBob, nss, opts); - otherNsEntryBob.doneFast(); - } - otherNss.doneFast(); - } - - // bypassDocumentValidation - if (_hasField.bypassDocumentValidation) { - bob.append(AggregateCommandRequest::kBypassDocumentValidationFieldName, - _bypassDocumentValidation); - } - - // We don't store the specified batch size values since they don't matter. - // Provide an arbitrary literal long here. - - tassert(78429, - "Serialization policy not supported - original values have been discarded", - opts.literalPolicy != LiteralSerializationPolicy::kUnchanged); - - if (_hasField.batchSize) { - // cursor - BSONObjBuilder cursorInfo = bob.subobjStart(AggregateCommandRequest::kCursorFieldName); - opts.appendLiteral(&cursorInfo, SimpleCursorOptions::kBatchSizeFieldName, 0ll); - cursorInfo.doneFast(); - } - - if (_hasField.explain) { - // The verbosity can be explicitly set by using the .explain() command, but when using the - // flag {explain: true} it is set to 'queryPlanner'. - bob.append(AggregateCommandRequest::kExplainFieldName, - ExplainOptions::verbosityString(_verbosity.value())); - } - - // The values here don't matter (assuming we're not using the 'kUnchanged' policy). - tassert(8949601, - "Serialization policy not supported - original values have been discarded", - opts.literalPolicy != LiteralSerializationPolicy::kUnchanged); - if (_hasField.passthroughToShard) { - BSONObjBuilder passthroughToShardInfo = - bob.subobjStart(AggregateCommandRequest::kPassthroughToShardFieldName); - static const PassthroughToShardOptions representativePassthroughOptions = []() { - PassthroughToShardOptions passthroughOpts; - // The value doesn't matter since we will only use this for shapified output. - passthroughOpts.setShard("?"); - return passthroughOpts; - }(); - representativePassthroughOptions.serialize(&passthroughToShardInfo, opts); - passthroughToShardInfo.doneFast(); - } -} - -size_t AggCmdComponents::size() const { - return sizeof(AggCmdComponents) + - std::accumulate(involvedNamespaces.begin(), - involvedNamespaces.end(), - 0, - [](int64_t total, const auto& nss) { return total + nss.size(); }); -} - -void AggKey::appendCommandSpecificComponents(BSONObjBuilder& bob, - const SerializationOptions& opts) const { - return _components.appendTo(bob, opts); -} - -AggKey::AggKey(AggregateCommandRequest request, - const Pipeline& pipeline, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - stdx::unordered_set<NamespaceString> involvedNamespaces, - const NamespaceString& origNss, - query_shape::CollectionType collectionType) - : Key(expCtx->opCtx, - std::make_unique<query_shape::AggCmdShape>( - request, origNss, involvedNamespaces, pipeline, expCtx), - request.getHint(), - request.getReadConcern(), - request.getMaxTimeMS().has_value(), - collectionType), - _components(request, std::move(involvedNamespaces)) {} - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/agg_key.h b/src/mongo/db/query/query_stats/agg_key.h deleted file mode 100644 index 38b80e28006..00000000000 --- a/src/mongo/db/query/query_stats/agg_key.h +++ /dev/null @@ -1,129 +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. - */ - -#pragma once - -#include <cstdint> -#include <utility> - -#include <absl/container/node_hash_map.h> -#include <boost/move/utility_core.hpp> -#include <boost/none.hpp> -#include <boost/optional/optional.hpp> -#include <boost/smart_ptr/intrusive_ptr.hpp> - -#include "mongo/base/string_data.h" -#include "mongo/bson/bsonobj.h" -#include "mongo/bson/bsonobjbuilder.h" -#include "mongo/db/collection_type.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/operation_context.h" -#include "mongo/db/pipeline/aggregate_command_gen.h" -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/pipeline/pipeline.h" -#include "mongo/db/pipeline/variables.h" -#include "mongo/db/query/explain_options.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_stats/key.h" - -namespace mongo::query_stats { - -/** - * Struct representing the aggregate command's unique arguments which should be included in the - * query stats key. - */ -struct AggCmdComponents : public SpecificKeyComponents { - static constexpr StringData kOtherNssFieldName = "otherNss"_sd; - - AggCmdComponents(const AggregateCommandRequest&, - stdx::unordered_set<NamespaceString> involvedNamespaces); - - void HashValue(absl::HashState state) const final; - - void appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const; - - size_t size() const; - - stdx::unordered_set<NamespaceString> involvedNamespaces; - bool _bypassDocumentValidation; - const boost::optional<mongo::ExplainOptions::Verbosity> _verbosity; - - // This anonymous struct represents the presence of the member variables as C++ bit fields. - // In doing so, each of these boolean values takes up 1 bit instead of 1 byte. - struct HasField { - HasField() : batchSize(false), bypassDocumentValidation(false), explain(false) {} - bool batchSize : 1; - bool bypassDocumentValidation : 1; - bool explain : 1; - bool passthroughToShard : 1; - } _hasField; -}; - -/** - * Handles shapification for AggregateCommandRequests. Requires a pre-parsed pipeline in order to - * avoid parsing the raw pipeline multiple times, but users should be sure to provide a - * non-optimized pipeline. - */ -class AggKey final : public Key { -public: - AggKey(AggregateCommandRequest request, - const Pipeline& pipeline, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - stdx::unordered_set<NamespaceString> involvedNamespaces, - const NamespaceString& origNss, - query_shape::CollectionType collectionType = query_shape::CollectionType::kUnknown); - - const SpecificKeyComponents& specificComponents() const final { - return _components; - } - - // The default implementation of hashing for smart pointers is not a good one for our purposes. - // Here we overload them to actually take the hash of the object, rather than hashing the - // pointer itself. - template <typename H> - friend H AbslHashValue(H h, const std::unique_ptr<const AggKey>& key) { - return H::combine(std::move(h), *key); - } - template <typename H> - friend H AbslHashValue(H h, const std::shared_ptr<const AggKey>& key) { - return H::combine(std::move(h), *key); - } - - -protected: - void appendCommandSpecificComponents(BSONObjBuilder& bob, - const SerializationOptions& opts) const final override; - -private: - const AggCmdComponents _components; -}; -static_assert( - sizeof(AggKey) == sizeof(Key) + sizeof(AggCmdComponents), - "If the class' members have changed, this assert may need to be updated with a new value."); -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/agg_key_test.cpp b/src/mongo/db/query/query_stats/agg_key_test.cpp deleted file mode 100644 index 35d0ae20d86..00000000000 --- a/src/mongo/db/query/query_stats/agg_key_test.cpp +++ /dev/null @@ -1,204 +0,0 @@ -/** - * Copyright (C) 2024-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 <boost/smart_ptr/intrusive_ptr.hpp> - -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/pipeline/pipeline.h" -#include "mongo/db/query/query_shape/agg_cmd_shape.h" -#include "mongo/db/query/query_stats/agg_key.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/idl/basic_types.h" -#include "mongo/unittest/unittest.h" -#include "mongo/util/intrusive_counter.h" - -namespace mongo::query_stats { - -namespace { - -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - -static constexpr auto collectionType = query_shape::CollectionType::kCollection; - -class AggKeyTest : public ServiceContextTest { -public: - static std::unique_ptr<const Key> makeAggKeyFromRawPipeline( - const std::vector<BSONObj>& rawPipeline) { - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - AggregateCommandRequest acr(kDefaultTestNss); - acr.setPipeline(rawPipeline); - auto pipeline = Pipeline::parse(rawPipeline, expCtx); - return std::make_unique<AggKey>(acr, - *pipeline, - expCtx, - pipeline->getInvolvedCollections(), - acr.getNamespace(), - collectionType); - } - size_t namespaceSize(stdx::unordered_set<NamespaceString> involvedNamespaces) { - return std::accumulate(involvedNamespaces.begin(), - involvedNamespaces.end(), - 0, - [](int64_t total, const auto& nss) { return total + nss.size(); }); - } -}; - -TEST_F(AggKeyTest, SizeOfAggCmdComponents) { - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - auto rawPipeline = {fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })")}; - - AggregateCommandRequest acr(kDefaultTestNss); - acr.setPipeline(rawPipeline); - auto pipeline = Pipeline::parse(rawPipeline, expCtx); - auto namespaces = pipeline->getInvolvedCollections(); - auto aggComponents = std::make_unique<AggCmdComponents>(acr, namespaces); - - const auto minimumSize = sizeof(SpecificKeyComponents) + - sizeof(stdx::unordered_set<NamespaceString>) + 2 /*size for bool and HasField*/ + - sizeof(boost::optional<mongo::ExplainOptions::Verbosity>) + namespaceSize(namespaces); - ASSERT_GTE(aggComponents->size(), minimumSize); - ASSERT_LTE(aggComponents->size(), minimumSize + 8 /*padding*/); -} - -TEST_F(AggKeyTest, EquivalentAggCmdComponentSizes) { - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - auto rawPipeline = {fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })")}; - - // Set different values in the command request. - AggregateCommandRequest acrBypassTrue(kDefaultTestNss); - acrBypassTrue.setPipeline(rawPipeline); - acrBypassTrue.setBypassDocumentValidation(true); - auto pipeline = Pipeline::parse(rawPipeline, expCtx); - auto namespaces = pipeline->getInvolvedCollections(); - auto aggComponentsBypassTrue = std::make_unique<AggCmdComponents>(acrBypassTrue, namespaces); - - - AggregateCommandRequest acrBypassFalse(kDefaultTestNss); - acrBypassFalse.setPipeline(rawPipeline); - acrBypassFalse.setBypassDocumentValidation(false); - auto aggComponentsBypassFalse = std::make_unique<AggCmdComponents>(acrBypassFalse, namespaces); - - ASSERT_EQ(aggComponentsBypassTrue->size(), aggComponentsBypassFalse->size()); -} - -TEST_F(AggKeyTest, DifferentAggCmdComponentSizes) { - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - auto rawPipeline = {fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })")}; - - AggregateCommandRequest acr(kDefaultTestNss); - acr.setPipeline(rawPipeline); - // Manually creating different namespaces for testing purposes. - const auto namespaceStringOne = NamespaceString("testDB.testColl1"); - const auto namespaceStringTwo = NamespaceString("testDB.testColl2"); - - stdx::unordered_set<NamespaceString> smallNamespaces; - smallNamespaces.insert(namespaceStringOne); - - stdx::unordered_set<NamespaceString> largeNamespaces; - largeNamespaces.insert(namespaceStringOne); - largeNamespaces.insert(namespaceStringTwo); - - auto smallAggComponents = std::make_unique<AggCmdComponents>(acr, smallNamespaces); - auto largeAggComponents = std::make_unique<AggCmdComponents>(acr, largeNamespaces); - - ASSERT_LT(namespaceSize(smallNamespaces), namespaceSize(largeNamespaces)); - ASSERT_LT(smallAggComponents->size(), largeAggComponents->size()); -} - -// Testing item in opCtx that should impact key size. -TEST_F(AggKeyTest, SizeOfAggKeyWithAndWithoutWriteConcern) { - auto rawPipeline = {fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })")}; - - auto keyWithoutComment = makeAggKeyFromRawPipeline(rawPipeline); - - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - AggregateCommandRequest acrWithComment(kDefaultTestNss); - acrWithComment.setPipeline(rawPipeline); - expCtx->opCtx->setComment(BSON("comment" - << " foo")); - auto pipelineWithComment = Pipeline::parse(rawPipeline, expCtx); - auto keyWithComment = std::make_unique<AggKey>(acrWithComment, - *pipelineWithComment, - expCtx, - pipelineWithComment->getInvolvedCollections(), - acrWithComment.getNamespace(), - collectionType); - - ASSERT_LT(keyWithoutComment->size(), keyWithComment->size()); -} - -// Testing item in command request that should impact key size. -TEST_F(AggKeyTest, SizeOfAggKeyWithAndWithoutReadConcern) { - auto rawPipeline = {fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })")}; - - auto keyWithoutReadConcern = makeAggKeyFromRawPipeline(rawPipeline); - - auto expCtx = make_intrusive<ExpressionContextForTest>(kDefaultTestNss); - AggregateCommandRequest acrWithReadConcern(kDefaultTestNss); - acrWithReadConcern.setPipeline(rawPipeline); - acrWithReadConcern.setReadConcern(fromjson(R"({level: "local"})")); - auto pipelineWithReadConcern = Pipeline::parse(rawPipeline, expCtx); - auto keyWithReadConcern = - std::make_unique<AggKey>(acrWithReadConcern, - *pipelineWithReadConcern, - expCtx, - pipelineWithReadConcern->getInvolvedCollections(), - acrWithReadConcern.getNamespace(), - collectionType); - - ASSERT_LT(keyWithoutReadConcern->size(), keyWithReadConcern->size()); -} -} // namespace -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/aggregate_key_generator.cpp b/src/mongo/db/query/query_stats/aggregate_key_generator.cpp deleted file mode 100644 index f175df296f2..00000000000 --- a/src/mongo/db/query/query_stats/aggregate_key_generator.cpp +++ /dev/null @@ -1,185 +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 "mongo/db/query/query_stats/aggregate_key_generator.h" - -#include "mongo/db/pipeline/pipeline.h" -#include "mongo/db/query/query_shape.h" -#include "mongo/db/query/serialization_options.h" -#include "mongo/db/query/shape_helpers.h" - -namespace mongo::query_stats { - -BSONObj AggregateKeyGenerator::generate( - OperationContext* opCtx, - boost::optional<SerializationOptions::TokenizeIdentifierFunc> hmacPolicy) const { - // TODO SERVER-76087 We will likely want to set a flag here to stop $search from calling out - // to mongot. - auto expCtx = makeDummyExpCtx(opCtx); - SerializationOptions opts{LiteralSerializationPolicy::kToDebugTypeString}; - if (hmacPolicy) { - opts.transformIdentifiers = true; - opts.transformIdentifiersCallback = *hmacPolicy; - opts.includePath = true; - opts.verbosity = boost::none; - } - - return makeQueryStatsKey(opts, expCtx); -} - -void AggregateKeyGenerator::appendCommandSpecificComponents( - BSONObjBuilder& bob, const SerializationOptions& opts) const { - // cursor - if (auto param = _request.getCursor().getBatchSize()) { - BSONObjBuilder cursorInfo = bob.subobjStart(AggregateCommandRequest::kCursorFieldName); - opts.appendLiteral(&cursorInfo, - SimpleCursorOptions::kBatchSizeFieldName, - static_cast<long long>(param.get())); - cursorInfo.doneFast(); - } - - // maxTimeMS - if (auto param = _request.getMaxTimeMS()) { - opts.appendLiteral(&bob, - AggregateCommandRequest::kMaxTimeMSFieldName, - static_cast<long long>(param.get())); - } - - // bypassDocumentValidation - if (auto param = _request.getBypassDocumentValidation()) { - opts.appendLiteral( - &bob, AggregateCommandRequest::kBypassDocumentValidationFieldName, bool(param.get())); - } - - // otherNss - if (!_involvedNamespaces.empty()) { - BSONArrayBuilder otherNss = bob.subarrayStart(kOtherNssFieldName); - for (const auto& nss : _involvedNamespaces) { - BSONObjBuilder otherNsEntryBob = otherNss.subobjStart(); - shape_helpers::appendNamespaceShape(otherNsEntryBob, nss, opts); - otherNsEntryBob.doneFast(); - } - otherNss.doneFast(); - } -} - -BSONObj AggregateKeyGenerator::makeQueryStatsKey( - const SerializationOptions& opts, const boost::intrusive_ptr<ExpressionContext>& expCtx) const { - auto pipeline = Pipeline::parse(_request.getPipeline(), expCtx); - return _makeQueryStatsKeyHelper(opts, expCtx, *pipeline); -} - -BSONObj AggregateKeyGenerator::_makeQueryStatsKeyHelper( - const SerializationOptions& opts, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - const Pipeline& pipeline) const { - return generateWithQueryShape( - query_shape::extractQueryShape(_request, pipeline, opts, expCtx, _origNss), opts); -} - -namespace { - -int64_t sum(const std::initializer_list<int64_t>& sizes) { - return std::accumulate(sizes.begin(), sizes.end(), 0, std::plus{}); -} - -int64_t size(const std::vector<BSONObj>& objects) { - return std::accumulate(objects.begin(), objects.end(), 0, [](int64_t total, const auto& obj) { - // Include the 'sizeof' to account for the variable number in the vector. - return total + sizeof(BSONObj) + obj.objsize(); - }); -} - -int64_t size(const boost::optional<PassthroughToShardOptions>& passthroughToShardOpts) { - if (!passthroughToShardOpts) { - return 0; - } - return passthroughToShardOpts->getShard().size(); -} - -int64_t size(const boost::optional<ExchangeSpec>& exchange) { - if (!exchange) { - return 0; - } - return sum( - {exchange->getKey().objsize(), - (exchange->getBoundaries() ? size(exchange->getBoundaries().get()) : 0), - (exchange->getConsumerIds() ? 4 * static_cast<int64_t>(exchange->getConsumerIds()->size()) - : 0)}); -} - -int64_t size(const boost::optional<EncryptionInformation>& encryptInfo) { - if (!encryptInfo) { - return 0; - } - tasserted(7659700, - "Unexpected encryption information - not expecting to collect query shape stats on " - "encrypted querys"); -} - -int64_t size(const StringData& str) { - return str.size(); -} - -int64_t size(const boost::optional<BSONObj>& obj) { - return optionalObjSize(obj); -} - -// variadic base case. -template <typename T> -int64_t sumOfSizes(const T& t) { - return size(t); -} - -// variadic recursive case. Making the compiler expand the pluses everywhere to give us good -// formatting at the call site. sumOfSizes(x, y, z) rather than size(x) + size(y) + size(z). -template <typename T, typename... Args> -int64_t sumOfSizes(const T& t, const Args&... args) { - return size(t) + sumOfSizes(args...); -} - -int64_t aggRequestSize(const AggregateCommandRequest& request) { - return sumOfSizes(request.getPipeline(), - request.getLet(), - request.getUnwrappedReadPref(), - request.getExchange(), - request.getPassthroughToShard(), - request.getEncryptionInformation(), - request.getDbName()); -} - -} // namespace - -int64_t AggregateKeyGenerator::doGetSize() const { - return sum({sizeof(*this), - static_cast<int64_t>(_origNss.size()), - optionalObjSize(_initialQueryStatsKey), - aggRequestSize(_request)}); -} -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/find_key.cpp b/src/mongo/db/query/query_stats/find_key.cpp deleted file mode 100644 index 437c75aecaa..00000000000 --- a/src/mongo/db/query/query_stats/find_key.cpp +++ /dev/null @@ -1,69 +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 "mongo/db/query/query_stats/find_key.h" - -namespace mongo::query_stats { - -void FindCmdComponents::appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const { - - if (_hasField.allowPartialResults) { - bob.append(FindCommandRequest::kAllowPartialResultsFieldName, _allowPartialResults); - } - - // Fields for literal redaction. Adds batchSize, and noCursorTimeOut. - - if (_hasField.noCursorTimeout) { - bob.append(FindCommandRequest::kNoCursorTimeoutFieldName, _noCursorTimeout); - } - - // We don't store the specified batch size value since it doesn't matter. - // Provide an arbitrary literal long here. - tassert(7973602, - "Serialization policy not supported - original values have been discarded", - opts.literalPolicy != LiteralSerializationPolicy::kUnchanged); - - if (_hasField.batchSize) { - opts.appendLiteral(&bob, FindCommandRequest::kBatchSizeFieldName, 0ll); - } -} - -std::unique_ptr<FindCommandRequest> FindKey::reparse(OperationContext* opCtx) const { - auto fcr = - static_cast<const query_shape::FindCmdShape*>(universalComponents()._queryShape.get()) - ->toFindCommandRequest(); - if (_components._hasField.allowPartialResults) - fcr->setAllowPartialResults(_components._allowPartialResults); - if (_components._hasField.noCursorTimeout) - fcr->setNoCursorTimeout(_components._noCursorTimeout); - if (_components._hasField.batchSize) - fcr->setBatchSize(1ll); - return fcr; -} -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/find_key.h b/src/mongo/db/query/query_stats/find_key.h deleted file mode 100644 index 8578a77e573..00000000000 --- a/src/mongo/db/query/query_stats/find_key.h +++ /dev/null @@ -1,152 +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. - */ - -#pragma once - -#include <memory> - -#include "mongo/db/namespace_string.h" -#include "mongo/db/operation_context.h" -#include "mongo/db/query/query_shape/find_cmd_shape.h" -#include "mongo/db/query/query_stats/key.h" - -namespace mongo::query_stats { - -struct FindCmdComponents : public SpecificKeyComponents { - FindCmdComponents(const FindCommandRequest* findCmd) - : _allowPartialResults(findCmd->getAllowPartialResults().value_or(false)), - _noCursorTimeout(findCmd->getNoCursorTimeout().value_or(false)), - _hasField() { - _hasField.batchSize = findCmd->getBatchSize().has_value(); - _hasField.allowPartialResults = findCmd->getAllowPartialResults().has_value(); - _hasField.noCursorTimeout = findCmd->getNoCursorTimeout().has_value(); - } - - std::size_t size() const { - return sizeof(FindCmdComponents); - } - - void HashValue(absl::HashState state) const final { - absl::HashState::combine( - std::move(state), _hasField, _allowPartialResults, _noCursorTimeout); - } - - void appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const; - - // Avoid using boost::optional here because it creates extra padding at the beginning of the - // struct. Since each QueryStatsEntry can have its own FindKey, it's better to - // minimize the struct's size as much as possible. - - // Preserved literal. - bool _allowPartialResults; - bool _noCursorTimeout; - - // This anonymous struct represents the presence of the member variables as C++ bit fields. - // In doing so, each of these boolean values takes up 1 bit instead of 1 byte. - struct HasField { - HasField() : batchSize(false), allowPartialResults(false), noCursorTimeout(false) {} - bool batchSize : 1; - bool allowPartialResults : 1; - bool noCursorTimeout : 1; - bool operator==(const HasField& other) const { - return batchSize == other.batchSize && - allowPartialResults == other.allowPartialResults && - noCursorTimeout == other.noCursorTimeout; - } - - } _hasField; - - template <typename H> - friend H AbslHashValue(H h, const HasField& hasField) { - return H::combine(std::move(h), - hasField.batchSize, - hasField.noCursorTimeout, - hasField.allowPartialResults); - } -}; - -// This static assert checks to ensure that the struct's size is changed thoughtfully. If adding -// or otherwise changing the members, this assert may be updated with care. -static_assert( - // Expecting two bytes for allowPartialResults and noCursorTimeout, and another - // byte for _hasField. For alignment reasons (alignment is 8 bytes here), this means the trailer - // will bring up the total bytecount to a multiple of 8. - sizeof(FindCmdComponents) <= sizeof(SpecificKeyComponents) + 8, - "Size of FindCmdComponents is too large! " - "Make sure that the struct has been align- and padding-optimized. " - "If the struct's members have changed, this assert may need to be updated with a new " - "value."); - -class FindKey final : public Key { -public: - FindKey(const boost::intrusive_ptr<ExpressionContext>& expCtx, - const ParsedFindCommand& request, - query_shape::CollectionType collectionType = query_shape::CollectionType::kUnknown) - : Key(expCtx->opCtx, - std::make_unique<query_shape::FindCmdShape>(request, expCtx), - request.findCommandRequest->getHint(), - request.findCommandRequest->getReadConcern(), - request.findCommandRequest->getMaxTimeMS().has_value(), - collectionType), - _components(request.findCommandRequest.get()) {} - - // The default implementation of hashing for smart pointers is not a good one for our purposes. - // Here we overload them to actually take the hash of the object, rather than hashing the - // pointer itself. - template <typename H> - friend H AbslHashValue(H h, const std::unique_ptr<const FindKey>& key) { - return H::combine(std::move(h), *key); - } - template <typename H> - friend H AbslHashValue(H h, const std::shared_ptr<const FindKey>& key) { - return H::combine(std::move(h), *key); - } - - const SpecificKeyComponents& specificComponents() const { - return _components; - } - -private: - void appendCommandSpecificComponents(BSONObjBuilder& bob, - const SerializationOptions& opts) const final { - _components.appendTo(bob, opts); - } - - std::unique_ptr<FindCommandRequest> reparse(OperationContext* opCtx) const; - - FindCmdComponents _components; -}; - -// This static assert checks to ensure that the struct's size is changed thoughtfully. If adding -// or otherwise changing the members, this assert may be updated with care. -static_assert(sizeof(FindKey) == sizeof(Key) + sizeof(FindCmdComponents), - "If the class' members have changed, this assert may need to be updated with a new " - "value and the size calcuation will need to be changed."); - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/find_key_test.cpp b/src/mongo/db/query/query_stats/find_key_test.cpp deleted file mode 100644 index 6c34ba5a606..00000000000 --- a/src/mongo/db/query/query_stats/find_key_test.cpp +++ /dev/null @@ -1,133 +0,0 @@ -/** - * Copyright (C) 2022-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 "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/parsed_find_command.h" -#include "mongo/db/query/query_stats/find_key.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_stats { - -namespace { -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - -static constexpr auto collectionType = query_shape::CollectionType::kCollection; - -class FindKeyTest : public ServiceContextTest { -public: - static std::unique_ptr<const Key> makeFindKeyFromQuery(const BSONObj& filter) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcr)})); - return std::make_unique<FindKey>(expCtx, *parsedFind, collectionType); - } -}; - -TEST_F(FindKeyTest, SizeOfFindCmdComponents) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - auto query = BSON("query" << 1 << "xEquals" << 42); - fcr->setFilter(query.getOwned()); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcr)})); - auto findComponents = std::make_unique<FindCmdComponents>(parsedFind->findCommandRequest.get()); - - ASSERT_GTE(findComponents->size(), sizeof(SpecificKeyComponents) + 3 /*bools and HasField*/); - ASSERT_LTE(findComponents->size(), - sizeof(SpecificKeyComponents) + 8 /*bools, HasField, and padding*/); -} - -TEST_F(FindKeyTest, EquivalentFindCmdComponentsSizes) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto query = BSON("query" << 1 << "xEquals" << 42); - - // Set different fields in the find commands. - auto fcrCursorTimeout = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcrCursorTimeout->setFilter(query.getOwned()); - fcrCursorTimeout->setNoCursorTimeout(true); - auto parsedFindCursorTimeout = - uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcrCursorTimeout)})); - auto findComponentsCursorTimeout = - std::make_unique<FindCmdComponents>(parsedFindCursorTimeout->findCommandRequest.get()); - - auto fcrAllowPartial = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcrAllowPartial->setFilter(query.getOwned()); - fcrAllowPartial->setAllowPartialResults(true); - auto parsedFindAllowPartial = - uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcrAllowPartial)})); - auto findComponentsAllowPartial = - std::make_unique<FindCmdComponents>(parsedFindAllowPartial->findCommandRequest.get()); - - ASSERT_EQ(findComponentsCursorTimeout->size(), findComponentsAllowPartial->size()); -} - -// Testing item from opCtx that should impact key size. -TEST_F(FindKeyTest, SizeOfFindKeyWithAndWithoutComment) { - auto query = BSON("query" << 1 << "xEquals" << 42); - - auto keyWithoutComment = makeFindKeyFromQuery(query); - - auto opCtx = makeOperationContext(); - auto fcrWithComment = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcrWithComment->setFilter(query.getOwned()); - opCtx->setComment(BSON("comment" - << " foo")); - auto expCtxWithComment = make_intrusive<ExpressionContext>( - opCtx.get(), *fcrWithComment, nullptr, true /* mayDbProfile*/); - auto parsedFindWithComment = - uassertStatusOK(parsed_find_command::parse(expCtxWithComment, {std::move(fcrWithComment)})); - auto keyWithComment = std::make_unique<query_stats::FindKey>( - expCtxWithComment, *parsedFindWithComment, collectionType); - - ASSERT_LT(keyWithoutComment->size(), keyWithComment->size()); -} - -// Testing item from command request that should impact key size. -TEST_F(FindKeyTest, SizeOfFindKeyWithAndWithoutReadConcern) { - auto query = BSON("query" << 1 << "xEquals" << 42); - - auto keyWithoutReadConcern = makeFindKeyFromQuery(query); - - auto expCtxWithReadConcern = make_intrusive<ExpressionContextForTest>(); - auto fcrWithReadConcern = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcrWithReadConcern->setFilter(query.getOwned()); - fcrWithReadConcern->setReadConcern(fromjson(R"({level: "local"})")); - auto parsedFindWithReadConcern = uassertStatusOK( - parsed_find_command::parse(expCtxWithReadConcern, {std::move(fcrWithReadConcern)})); - auto keyWithReadConcern = std::make_unique<query_stats::FindKey>( - expCtxWithReadConcern, *parsedFindWithReadConcern, collectionType); - - ASSERT_LT(keyWithoutReadConcern->size(), keyWithReadConcern->size()); -} - - -} // namespace -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/key.cpp b/src/mongo/db/query/query_stats/key.cpp deleted file mode 100644 index f282ef21a2a..00000000000 --- a/src/mongo/db/query/query_stats/key.cpp +++ /dev/null @@ -1,223 +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 "mongo/db/query/query_stats/key.h" - -#include "mongo/db/query/query_stats/query_stats_helpers.h" -#include "mongo/rpc/metadata/client_metadata.h" - -namespace mongo::query_stats { - -namespace { - -BSONObj scrubHighCardinalityFields(const ClientMetadata* clientMetadata) { - if (!clientMetadata) { - return BSONObj(); - } - return clientMetadata->documentWithoutMongosInfo(); -} - -BSONObj shapifyReadPreference(boost::optional<BSONObj> readPreference) { - if (!readPreference) { - return BSONObj(); - } - - BSONObjBuilder builder; - for (const auto& elem : *readPreference) { - if (elem.fieldNameStringData() != "tags"_sd) { - builder.append(elem); - continue; - } - - // Sort the $readPreference tags so that different orderings still map to one query stats - // store key. - BSONObjSet sortedTags = SimpleBSONObjComparator::kInstance.makeBSONObjSet(); - for (const auto& tag : elem.Array()) { - sortedTags.insert(tag.Obj()); - } - - BSONArrayBuilder arrBuilder(builder.subarrayStart("tags"_sd)); - for (const auto& tag : sortedTags) { - arrBuilder.append(tag); - } - } - return builder.obj(); -} - -} // namespace - -UniversalKeyComponents::UniversalKeyComponents(std::unique_ptr<query_shape::Shape> queryShape, - const ClientMetadata* clientMetadata, - boost::optional<BSONObj> commentObj, - boost::optional<BSONObj> hint, - boost::optional<BSONObj> readPreference, - boost::optional<BSONObj> writeConcern, - boost::optional<BSONObj> readConcern, - std::unique_ptr<APIParameters> apiParams, - query_shape::CollectionType collectionType, - bool maxTimeMS) - : _clientMetaData(scrubHighCardinalityFields(clientMetadata)), - _commentObj(commentObj.value_or(BSONObj()).getOwned()), - _hintObj(hint.value_or(BSONObj()).getOwned()), - _writeConcern(writeConcern.value_or(BSONObj()).getOwned()), - _shapifiedReadPreference(shapifyReadPreference(readPreference)), - _shapifiedReadConcern(shapifyReadConcern(readConcern.value_or(BSONObj()))), - _comment(commentObj ? _commentObj.firstElement() : BSONElement()), - _queryShape(std::move(queryShape)), - _apiParams(std::move(apiParams)), - _clientMetaDataHash(clientMetadata ? clientMetadata->hashWithoutMongosInfo() - : simpleHash(BSONObj())), - _collectionType(collectionType), - _hasField() { - _hasField.clientMetaData = bool(clientMetadata); - _hasField.comment = bool(commentObj); - _hasField.hint = bool(hint); - _hasField.readPreference = bool(readPreference); - _hasField.writeConcern = bool(writeConcern); - _hasField.readConcern = bool(readConcern); - _hasField.maxTimeMS = maxTimeMS; - tassert(7973600, "shape must not be null", _queryShape); -} - -BSONObj UniversalKeyComponents::shapifyReadConcern(const BSONObj& readConcern, - const SerializationOptions& opts) { - // Read concern should not be considered a literal. - // afterClusterTime is distinct for every operation with causal consistency enabled. We - // normalize it in order not to blow out the queryStats store cache. - if (readConcern["afterClusterTime"].eoo() && readConcern["atClusterTime"].eoo()) { - return readConcern.copy(); - } else { - BSONObjBuilder bob; - - if (auto levelElem = readConcern["level"]) { - bob.append(levelElem); - } - if (auto afterClusterTime = readConcern["afterClusterTime"]) { - opts.appendLiteral(&bob, "afterClusterTime", afterClusterTime); - } - if (auto atClusterTime = readConcern["atClusterTime"]) { - opts.appendLiteral(&bob, "atClusterTime", atClusterTime); - } - return bob.obj(); - } -} - -size_t UniversalKeyComponents::size() const { - return sizeof(*this) + _queryShape->size() + - (_apiParams ? sizeof(*_apiParams) + shape_helpers::optionalSize(_apiParams->getAPIVersion()) - : 0) + - _hintObj.objsize() + (_hasField.clientMetaData ? _clientMetaData.objsize() : 0) + - _commentObj.objsize() + - (_hasField.readPreference ? _shapifiedReadPreference.objsize() : 0) + - (_hasField.readConcern ? _shapifiedReadConcern.objsize() : 0) + - (_hasField.writeConcern ? _writeConcern.objsize() : 0); -} - -void UniversalKeyComponents::appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const { - if (_hasField.comment) { - opts.appendLiteral(&bob, "comment", _comment); - } - - if (_hasField.readConcern) { - auto readConcernToAppend = _shapifiedReadConcern; - if (opts != SerializationOptions::kRepresentativeQueryShapeSerializeOptions) { - // The options aren't the same as the first time we shapified, so re-computation is - // necessary (e.g. use "?timestamp" instead of the representative Timestamp(0, 0)). - readConcernToAppend = shapifyReadConcern(_shapifiedReadConcern, opts); - } - bob.append("readConcern", readConcernToAppend); - } - - if (const auto& apiVersion = _apiParams->getAPIVersion()) { - bob.append("apiVersion", apiVersion.value()); - } - - if (const auto& apiStrict = _apiParams->getAPIStrict()) { - bob.append("apiStrict", apiStrict.value()); - } - - if (const auto& apiDeprecationErrors = _apiParams->getAPIDeprecationErrors()) { - bob.append("apiDeprecationErrors", apiDeprecationErrors.value()); - } - - if (_hasField.readPreference) { - bob.append("$readPreference", _shapifiedReadPreference); - } - - if (_hasField.writeConcern) { - bob.append("writeConcern", _writeConcern); - } - - if (_hasField.clientMetaData) { - bob.append("client", _clientMetaData); - } - if (_collectionType > query_shape::CollectionType::kUnknown) { - bob.append("collectionType", toStringData(_collectionType)); - } - if (!_hintObj.isEmpty()) { - bob.append("hint", shape_helpers::extractHintShape(_hintObj, opts)); - } - if (_hasField.maxTimeMS) { - opts.appendLiteral(&bob, "maxTimeMS", 0ll); - } -} -Key::Key(OperationContext* opCtx, - std::unique_ptr<query_shape::Shape> queryShape, - boost::optional<BSONObj> hint, - boost::optional<BSONObj> readConcern, - bool maxTimeMS, - query_shape::CollectionType collectionType) - : _universalComponents( - std::move(queryShape), - ClientMetadata::get(opCtx->getClient()), - opCtx->getCommentOwnedCopy(), - hint, - ReadPreferenceSetting::get(opCtx).usedDefaultReadPrefValue() - ? boost::none - : boost::make_optional(ReadPreferenceSetting::get(opCtx).toInnerBSON()), - opCtx->getWriteConcern().isImplicitDefaultWriteConcern() - ? boost::none - : boost::make_optional(opCtx->getWriteConcern().toBSON()), - readConcern, - std::make_unique<APIParameters>(APIParameters::get(opCtx)), - collectionType, - maxTimeMS) {} - -BSONObj Key::toBson(OperationContext* opCtx, const SerializationOptions& opts) const { - BSONObjBuilder bob; - - // We'll take care of appending this one outside of the appendTo() call below since it needs - // an OperationContext in some re-parsing cases. The rest is simpler. - bob.append("queryShape", _universalComponents._queryShape->toBson(opCtx, opts)); - - _universalComponents.appendTo(bob, opts); - appendCommandSpecificComponents(bob, opts); - return bob.obj(); -} -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/key.h b/src/mongo/db/query/query_stats/key.h deleted file mode 100644 index bb83fca82ed..00000000000 --- a/src/mongo/db/query/query_stats/key.h +++ /dev/null @@ -1,304 +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. - */ - -#pragma once - -#include <memory> - -#include "mongo/bson/bsonobj.h" -#include "mongo/db/api_parameters.h" -#include "mongo/db/collection_type.h" -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/db/query/query_shape/shape_helpers.h" -#include "mongo/db/query/query_stats/transform_algorithm_gen.h" -#include "mongo/rpc/metadata/client_metadata.h" - -namespace mongo::query_stats { - -/** - * A struct holding pieces of the command request that are a component of the query stats store key - * and are options/arguments to all supported query stats commands. - * - * This struct (and the SpecificKeyComponents) are split out as a separate inheritence hierarchy to - * make it easier to ensure each piece is hashed without sub-classes needing to enumerate the parent - * class's member variables. - */ -struct UniversalKeyComponents { - UniversalKeyComponents(std::unique_ptr<query_shape::Shape> queryShape, - const ClientMetadata* clientMetadata, - boost::optional<BSONObj> commentObj, - boost::optional<BSONObj> hint, - boost::optional<BSONObj> readPreference, - boost::optional<BSONObj> writeConcern, - boost::optional<BSONObj> readConcern, - std::unique_ptr<APIParameters> apiParams, - query_shape::CollectionType collectionType, - bool maxTimeMS); - /** - * Returns a copy of the read concern object. If there is an "afterClusterTime" or - * "atClusterTime" component, the timestamp is shapified according to 'opts'. - */ - static BSONObj shapifyReadConcern( - const BSONObj& readConcern, - const SerializationOptions& opts = - SerializationOptions::kRepresentativeQueryShapeSerializeOptions); - - size_t size() const; - - void appendTo(BSONObjBuilder& bob, const SerializationOptions& opts) const; - - // Avoid using boost::optional here because it creates extra padding at the beginning of the - // struct. Since each QueryStatsEntry has its own Key subclass, it's better to minimize - // the struct's size as much as possible. - - BSONObj _clientMetaData; // Preserve this value. - BSONObj _commentObj; // Shapify this value. - BSONObj _hintObj; // Preserve this value. - BSONObj _writeConcern; // Preserve this value. - - // Preserved literal except value of 'tags' field is sorted. - BSONObj _shapifiedReadPreference; - // Preserved literal except 'afterClusterTime' and 'atClusterTime' are shapified. - BSONObj _shapifiedReadConcern; - - // Separate the possibly-enormous BSONObj from the remaining members - - BSONElement _comment; - - std::unique_ptr<query_shape::Shape> _queryShape; - std::unique_ptr<APIParameters> _apiParams; // Preserve this value in the query shape. - - // Simple hash of the client metadata object. This value is stored separately because it is - // cached on the client to avoid re-computing on every operation. If no client metadata is - // present, this will be the hash of an empty BSON object (otherwise known as 0). - const unsigned long _clientMetaDataHash; - - // This value is not known when run a query is run on mongos over an unsharded collection, so it - // is not set through that code path. - query_shape::CollectionType _collectionType; - - // This anonymous struct represents the presence of the member variables as C++ bit fields. - // In doing so, each of these boolean values takes up 1 bit instead of 1 byte. - struct HasField { - HasField() - : clientMetaData(false), - comment(false), - hint(false), - readPreference(false), - writeConcern(false), - readConcern(false), - maxTimeMS(false) {} - - bool clientMetaData : 1; - bool comment : 1; - bool hint : 1; - bool readPreference : 1; - bool writeConcern : 1; - bool readConcern : 1; - bool maxTimeMS : 1; - } _hasField; -}; - -/** - * A base class for sub-classes to derive from to expose the hashing ability for all of their - * sub-components. - * - * This struct (and the UniversalKeyComponents) are split out as a separate inheritence hierarchy to - * make it easier to ensure each piece is hashed without sub-classes needing to enumerate the parent - * class's member variables. - */ -struct SpecificKeyComponents { - virtual ~SpecificKeyComponents() {} - - virtual void HashValue(absl::HashState state) const = 0; - - /** - * Sub-classes should implement this to report how much memory is used. This is important to do - * carefully since we are under a budget in the query stats store and use this to do the - * accounting. Implementers should include sizeof(*derivedThis) and be sure to also include the - * size of any owned pointer-like objects such as BSONObj or NamespaceString which are - * indirectly using memory elsehwhere. - * - * We cannot just use sizeof() because there are some variable size data members (like BSON - * objects) which depend on the particular instance. - */ - virtual size_t size() const = 0; -}; - -template <typename H> -H AbslHashValue(H state, const SpecificKeyComponents& value) { - value.HashValue(absl::HashState::Create(&state)); - return std::move(state); -} - -template <typename H> -H AbslHashValue(H h, const UniversalKeyComponents& components) { - return H::combine(std::move(h), - *components._queryShape, - components._clientMetaDataHash, - // Note we use the comment's type in the hash function. - components._comment.type(), - simpleHash(components._hintObj), - simpleHash(components._shapifiedReadPreference), - simpleHash(components._writeConcern), - simpleHash(components._shapifiedReadConcern), - components._apiParams ? APIParameters::Hash{}(*components._apiParams) : 0, - components._collectionType, - components._hasField); -} - -template <typename H> -H AbslHashValue(H h, const UniversalKeyComponents::HasField& hasField) { - return H::combine(std::move(h), - hasField.clientMetaData, - hasField.comment, - hasField.hint, - hasField.readPreference, - hasField.writeConcern, - hasField.readConcern, - hasField.maxTimeMS); -} - - -// This static assert checks to ensure that the struct's size is changed thoughtfully. If adding -// or otherwise changing the members, this assert may be updated with care. -static_assert( - sizeof(UniversalKeyComponents) <= sizeof(query_shape::Shape) + 6 * sizeof(BSONObj) + - sizeof(BSONElement) + sizeof(std::unique_ptr<APIParameters>) + - sizeof(query_shape::CollectionType) + sizeof(query_shape::QueryShapeHash) + - sizeof(int64_t), - "Size of Key is too large! " - "Make sure that the struct has been align- and padding-optimized. " - "If the struct's members have changed, this assert may need to be updated with a new value."); - -/** - * An abstract base class representing a query stats store key for a given request. All query stats - * store entries should include some common elements, tracked in `_universalComponents`. For - * example, everything tracked must have a `query_shape::Shape`. - * - * Subclasses can add more components to include as discriminating factors in which entries should - * be tracked separately. For example, two find commands which are identical except in their read - * concern should be tracked differently. Maybe they will have quite different performance - * characteristics or help us determine when the read concern was changed by the client. - * - * The interface to do this is to split out the state/memory for these components as a separate - * struct which can indpendently hash itself and compute its size (both of which are important for - * the query stats store). Subclasses of Key itself should not have any meaningfully sized - * state other than the 'specificComponents().' - */ -class Key { -public: - virtual ~Key() = default; - - /** - * All Keys will share these characteristics as part of their query stats store key. - * Returns an unowned reference so the caller must ensure the result does not outlive this - * Key instance. - */ - const auto& universalComponents() const { - return _universalComponents; - } - - /** - * Different commands will have different components they want to be included in the query stats - * store key. This interface allows them to do so and easily have those components incorporated - * into this key generation and hashing. - */ - virtual const SpecificKeyComponents& specificComponents() const = 0; - - /** - * Materializes the query stats store key. Not expected to be used on ingestion, since we should - * store this object and its components directly in their native C++ data structures - we can - * use the absl::Hash<query_stats::Key>{}() API to look them up. Instead, this may be useful to - * display the key (as it is used for $queryStats) or perhaps one day persist it to storage. - */ - BSONObj toBson(OperationContext* opCtx, const SerializationOptions& opts) const; - - /** - * Convenience function. - */ - query_shape::QueryShapeHash getQueryShapeHash(OperationContext* opCtx) const { - // TODO (future ticket?) should we cache this somewhere else? - return _universalComponents._queryShape->sha256Hash(opCtx); - } - - size_t size() const { - return sizeof(Key) + specificComponents().size() + _universalComponents.size(); - } - - template <typename H> - friend H AbslHashValue(H h, const Key& key) { - return H::combine(std::move(h), key._universalComponents, key.specificComponents()); - } - - // The default implementation of hashing for smart pointers is not a good one for our purposes. - // Here we overload them to actually take the hash of the object, rather than hashing the - // pointer itself. - template <typename H> - friend H AbslHashValue(H h, const std::unique_ptr<const Key>& key) { - return H::combine(std::move(h), *key); - } - template <typename H> - friend H AbslHashValue(H h, const std::shared_ptr<const Key>& key) { - return H::combine(std::move(h), *key); - } - -protected: - /** - * Sub-classes can use this to instantiate a 'real' Key. 'queryShape' must not be null, - * but is tracked as a pointer since it is a virtual class and we want to own it here. - */ - Key(OperationContext* opCtx, - std::unique_ptr<query_shape::Shape> queryShape, - boost::optional<BSONObj> hint, - boost::optional<BSONObj> readConcern, - bool maxTimeMS, - query_shape::CollectionType collectionType = query_shape::CollectionType::kUnknown); - - /** - * With a given BSONObjBuilder, append the command-specific components of the query stats key. - * - * You may be wondering why this API is here rather than as a virtual method on - * CmdSpecificComponents - and that would be because many implementations can involve a re-parse - * of the request if it needs to serialize with different serialization options. This re-parsing - * process often needs the context of things tracked in _universalComponents, which is hard to - * access from the specific components. - */ - virtual void appendCommandSpecificComponents(BSONObjBuilder& bob, - const SerializationOptions& opts) const = 0; - -private: - UniversalKeyComponents _universalComponents; -}; -static_assert( - sizeof(Key) == sizeof(void*) /*vtable ptr*/ + sizeof(UniversalKeyComponents), - "If the class' members have changed, this assert may need to be updated with a new value."); -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/key_test.cpp b/src/mongo/db/query/query_stats/key_test.cpp deleted file mode 100644 index 69359d08bda..00000000000 --- a/src/mongo/db/query/query_stats/key_test.cpp +++ /dev/null @@ -1,177 +0,0 @@ -/** - * Copyright (C) 2024-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 "mongo/bson/bsonelement.h" -#include "mongo/db/collection_type.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/parsed_find_command.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_stats/find_key.h" -#include "mongo/db/query/query_stats/key.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_stats { - -namespace { -static const NamespaceString kDefaultTestNss = NamespaceString("testDB.testColl"); - - -struct DummyShapeSpecificComponents : public query_shape::CmdSpecificShapeComponents { - DummyShapeSpecificComponents(){}; - void HashValue(absl::HashState state) const {} - size_t size() const final { - return sizeof(DummyShapeSpecificComponents); - } -}; - -class DummyShape : public query_shape::Shape { -public: - DummyShape(NamespaceStringOrUUID nssOrUUID, - BSONObj collation, - DummyShapeSpecificComponents dummyComponents) - : Shape(nssOrUUID, collation) { - components = dummyComponents; - } - - const query_shape::CmdSpecificShapeComponents& specificComponents() const final { - return components; - } - - void appendCmdSpecificShapeComponents(BSONObjBuilder&, - OperationContext*, - const SerializationOptions& opts) const final {} - DummyShapeSpecificComponents components; -}; - -struct DummyKeyComponents : public SpecificKeyComponents { - DummyKeyComponents(){}; - - void HashValue(absl::HashState state) const {} - size_t size() const { - return sizeof(DummyKeyComponents); - } -}; - -class DummyKey : public Key { -public: - DummyKey(OperationContext* opCtx, - std::unique_ptr<query_shape::Shape> queryShape, - boost::optional<BSONObj> hint, - boost::optional<BSONObj> readConcern, - bool maxTimeMS, - query_shape::CollectionType collectionType, - DummyKeyComponents dummyComponents) - : Key(opCtx, std::move(queryShape), hint, readConcern, maxTimeMS, collectionType) { - components = dummyComponents; - } - const SpecificKeyComponents& specificComponents() const { - return components; - }; - void appendCommandSpecificComponents(BSONObjBuilder& bob, - const SerializationOptions& opts) const {}; - DummyKeyComponents components; -}; -class UniversalKeyTest : public ServiceContextTest {}; - -TEST_F(UniversalKeyTest, SizeOfUniversalComponents) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - // Make shape for testing. - auto collation = BSONObj{}; - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - auto shape = std::make_unique<DummyShape>(kDefaultTestNss, collation, *innerComponents); - - // Gather sizes and create universalComponents. - const auto shapeSize = shape->size(); - auto clientMetadata = ClientMetadata::get(expCtx->opCtx->getClient()); - - auto clientMetadataSize = clientMetadata ? clientMetadata->documentWithoutMongosInfo().objsize() - : BSONObj().objsize(); - - auto apiParams = std::make_unique<APIParameters>(APIParameters::get(expCtx->opCtx)); - const auto apiParamsSize = static_cast<size_t>( - apiParams ? sizeof(*apiParams) + shape_helpers::optionalSize(apiParams->getAPIVersion()) - : 0); - auto universalComponents = - std::make_unique<UniversalKeyComponents>(std::move(shape), - clientMetadata, - BSONObj(), - BSONObj(), - BSONObj(), - BSONObj(), - BSONObj(), - std::move(apiParams), - query_shape::CollectionType::kUnknown, - true); - - const auto minimumUniversalKeyComponentSize = sizeof(std::unique_ptr<query_shape::Shape>) + - (6 * sizeof(BSONObj)) + sizeof(std::unique_ptr<APIParameters>) + sizeof(BSONElement) + - sizeof(query_shape::CollectionType) + sizeof(unsigned long) + 1 /*HasField*/; - ASSERT_GTE(sizeof(UniversalKeyComponents), minimumUniversalKeyComponentSize); - ASSERT_LTE(sizeof(UniversalKeyComponents), minimumUniversalKeyComponentSize + 8 /*padding*/); - - ASSERT_GT(universalComponents->size(), - sizeof(UniversalKeyComponents) + shapeSize + clientMetadataSize + apiParamsSize); - ASSERT_LTE(universalComponents->size(), - sizeof(UniversalKeyComponents) + shapeSize + clientMetadataSize + - (5 * static_cast<size_t>(BSONObj().objsize())) + apiParamsSize); -} - -TEST_F(UniversalKeyTest, SizeOfSpecificComponents) { - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - auto keyComponents = std::make_unique<DummyKeyComponents>(); - - ASSERT_EQ(keyComponents->size(), sizeof(SpecificKeyComponents)); - ASSERT_EQ(sizeof(SpecificKeyComponents), sizeof(void*) /*vtable ptr*/); -} - -TEST_F(UniversalKeyTest, SizeOfKey) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - auto collation = BSONObj{}; - auto innerComponents = std::make_unique<DummyShapeSpecificComponents>(); - auto shape = std::make_unique<DummyShape>(kDefaultTestNss, collation, *innerComponents); - - auto keyComponents = std::make_unique<DummyKeyComponents>(); - - auto key = std::make_unique<DummyKey>(expCtx->opCtx, - std::move(shape), - BSONObj(), - BSONObj(), - false, - query_shape::CollectionType::kUnknown, - *keyComponents); - ASSERT_EQ(innerComponents->size(), key->specificComponents().size()); - ASSERT_EQ(sizeof(Key), sizeof(UniversalKeyComponents) + sizeof(void*)); - ASSERT_EQ(key->size(), - sizeof(Key) + key->universalComponents().size() + key->specificComponents().size()); -} -} // namespace -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats.cpp b/src/mongo/db/query/query_stats/query_stats.cpp deleted file mode 100644 index 2e6393aab34..00000000000 --- a/src/mongo/db/query/query_stats/query_stats.cpp +++ /dev/null @@ -1,441 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQueryStats - -#include "mongo/db/query/query_stats/query_stats.h" - -#include "mongo/crypto/hash_block.h" -#include "mongo/db/concurrency/d_concurrency.h" -#include "mongo/db/concurrency/locker.h" -#include "mongo/db/curop.h" -#include "mongo/db/exec/projection_executor_builder.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/pipeline/aggregate_command_gen.h" -#include "mongo/db/pipeline/process_interface/stub_mongo_process_interface.h" -#include "mongo/db/query/find_command_gen.h" -#include "mongo/db/query/plan_explainer.h" -#include "mongo/db/query/projection_ast_util.h" -#include "mongo/db/query/projection_parser.h" -#include "mongo/db/query/query_feature_flags_gen.h" -#include "mongo/db/query/query_planner_params.h" -#include "mongo/db/query/query_request_helper.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/db/query/query_stats/query_stats_on_parameter_change.h" -#include "mongo/db/query/sort_pattern.h" -#include "mongo/logv2/log.h" -#include "mongo/rpc/metadata/client_metadata.h" -#include "mongo/util/assert_util.h" -#include "mongo/util/debug_util.h" -#include "mongo/util/processinfo.h" -#include "mongo/util/system_clock_source.h" -#include <optional> - -namespace mongo::query_stats { - -Counter64 queryStatsStoreSizeEstimateBytesMetric; -ServerStatusMetricField<Counter64> displaySizeEstimateMetric( - "queryStats.queryStatsStoreSizeEstimateBytes", &queryStatsStoreSizeEstimateBytesMetric); - - -const Decorable<ServiceContext>::Decoration<std::unique_ptr<QueryStatsStoreManager>> - QueryStatsStoreManager::get = - ServiceContext::declareDecoration<std::unique_ptr<QueryStatsStoreManager>>(); - -const Decorable<ServiceContext>::Decoration<std::unique_ptr<RateLimiting>> - QueryStatsStoreManager::getRateLimiter = - ServiceContext::declareDecoration<std::unique_ptr<RateLimiting>>(); - - -namespace { - -Counter64 queryStatsEvictedMetric; -ServerStatusMetricField<Counter64> displayEvictedMetric("queryStats.numEvicted", - &queryStatsEvictedMetric); -Counter64 queryStatsRateLimitedRequestsMetric; -ServerStatusMetricField<Counter64> displayRateLimitMetric("queryStats.numRateLimitedRequests", - &queryStatsRateLimitedRequestsMetric); -Counter64 queryStatsStoreWriteErrorsMetric; -ServerStatusMetricField<Counter64> displayWriteErrorsMetric( - "queryStats.numQueryStatsStoreWriteErrors", &queryStatsStoreWriteErrorsMetric); - -/** - * Indicates whether or not query stats is enabled via the feature flag. - */ -bool isQueryStatsFeatureEnabled() { - // We need to call isVersionInitialized() first because this could run during startup while the - // FCV is still uninitialized. - if (serverGlobalParams.featureCompatibility.isVersionInitialized()) { - return feature_flags::gFeatureFlagQueryStats.isEnabled( - serverGlobalParams.featureCompatibility); - } - // (Generic FCV reference): This reference is needed to ensure we correctly initialize query - // stats during startup. - return feature_flags::gFeatureFlagQueryStats.isEnabledOnVersion( - multiversion::GenericFCV::kLatest); -} - -/** - * Cap the queryStats store size. - */ -size_t capQueryStatsStoreSize(size_t requestedSize) { - size_t cappedStoreSize = memory_util::capMemorySize( - requestedSize /*requestedSizeBytes*/, 1 /*maximumSizeGB*/, 25 /*percentTotalSystemMemory*/); - // If capped size is less than requested size, the queryStats store has been capped at its - // upper limit. - if (cappedStoreSize < requestedSize) { - LOGV2_DEBUG(7106502, - 1, - "The queryStats store size has been capped", - "cappedSize"_attr = cappedStoreSize); - } - return cappedStoreSize; -} - -/** - * Get the queryStats store size based on the query job's value. - */ -size_t getQueryStatsStoreSize() { - auto status = memory_util::MemorySize::parse(internalQueryStatsCacheSize.get()); - uassertStatusOK(status); - size_t requestedSize = memory_util::convertToSizeInBytes(status.getValue()); - return capQueryStatsStoreSize(requestedSize); -} - -void assertConfigurationAllowed() { - uassert(ErrorCodes::QueryFeatureNotAllowed, - "Cannot configure queryStats store. The feature flag is not enabled. Please restart " - "and specify the feature flag, or upgrade the feature compatibility version to one " - "where it is enabled by default.", - isQueryStatsFeatureEnabled()); -} - -class QueryStatsOnParamChangeUpdaterImpl final : public query_stats_util::OnParamChangeUpdater { -public: - void updateCacheSize(ServiceContext* serviceCtx, memory_util::MemorySize memSize) final { - assertConfigurationAllowed(); - auto requestedSize = memory_util::convertToSizeInBytes(memSize); - auto cappedSize = capQueryStatsStoreSize(requestedSize); - auto& queryStatsStoreManager = QueryStatsStoreManager::get(serviceCtx); - size_t numEvicted = queryStatsStoreManager->resetSize(cappedSize); - queryStatsEvictedMetric.increment(numEvicted); - } - - void updateSamplingRate(ServiceContext* serviceCtx, int samplingRate) { - assertConfigurationAllowed(); - QueryStatsStoreManager::getRateLimiter(serviceCtx).get()->setSamplingRate(samplingRate); - } -}; - -ServiceContext::ConstructorActionRegisterer queryStatsStoreManagerRegisterer{ - "QueryStatsStoreManagerRegisterer", [](ServiceContext* serviceCtx) { - // Note: it is possible that this is called before FCV is properly set up. The feature flags - // can only be specified at startup, but the feature compatibility version may change at - // runtime. If the feature compatibility version upgrades at runtime, the feature may now be - // enabled by default, even if the flag was not specified. To allow for this possibility, we - // will always configure a query stats store of the size currently specified by - // 'internalQueryStatsCacheSize', but we will prevent changing its shape or rate limit at - // runtime unless the feature flag is enabled (at whatever current FCV when the - // configuration setParameter command is run). - - query_stats_util::queryStatsStoreOnParamChangeUpdater(serviceCtx) = - std::make_unique<QueryStatsOnParamChangeUpdaterImpl>(); - size_t size = getQueryStatsStoreSize(); - auto&& globalQueryStatsStoreManager = QueryStatsStoreManager::get(serviceCtx); - // Initially the queryStats store used the same number of partitions as the plan cache, that - // is the number of cpu cores. However, with performance investigation we found that when - // the size of the partitions was too large, it took too long to copy out and read one - // partition. We are now capping each partition at 16MB (the largest size a query shape can - // be. If that gives us fewer partitions than we have cores, we set it to match the - // number of cores. The size needs to be cast to a double since we want to round up the - // number of partitions, and therefore need to avoid int division. - size_t numPartitions = std::ceil(double(size) / (16 * 1024 * 1024)); - auto numLogicalCores = ProcessInfo::getNumCores(); - if (numPartitions < numLogicalCores) { - numPartitions = numLogicalCores; - } - - globalQueryStatsStoreManager = - std::make_unique<QueryStatsStoreManager>(size, numPartitions); - auto configuredSamplingRate = internalQueryStatsRateLimit.load(); - QueryStatsStoreManager::getRateLimiter(serviceCtx) = std::make_unique<RateLimiting>( - configuredSamplingRate < 0 ? INT_MAX : configuredSamplingRate, Seconds{1}); - }}; - -/** - * Top-level checks for whether queryStats collection is enabled. If this returns false, we must - * go no further. - */ -bool isQueryStatsEnabled(const ServiceContext* serviceCtx) { - // During initialization, FCV may not yet be setup but queries could be run. We can't - // check whether queryStats should be enabled without FCV, so default to not recording - // those queries. - return isQueryStatsFeatureEnabled() && - QueryStatsStoreManager::get(serviceCtx)->getMaxSize() > 0; -} - -/** - * Internal check for whether we should collect metrics. This checks the rate limiting - * configuration for a global on/off decision and, if enabled, delegates to the rate limiter. - */ -bool shouldCollect(const ServiceContext* serviceCtx) { - // Cannot collect queryStats if sampling rate is not greater than 0. Note that we do not - // increment queryStatsRateLimitedRequestsMetric here since queryStats is entirely disabled. - auto samplingRate = QueryStatsStoreManager::getRateLimiter(serviceCtx)->getSamplingRate(); - if (samplingRate <= 0) { - LOGV2_DEBUG(8473001, - 5, - "sampling rate is <= 0, skipping this request", - "samplingRate"_attr = samplingRate); - return false; - } - // Check if rate limiting allows us to collect queryStats for this request. - if (samplingRate < INT_MAX && - !QueryStatsStoreManager::getRateLimiter(serviceCtx)->handleRequestSlidingWindow()) { - queryStatsRateLimitedRequestsMetric.increment(); - LOGV2_DEBUG(8473002, - 5, - "rate limited this request", - "samplingRate"_attr = samplingRate, - "totalLimited"_attr = queryStatsRateLimitedRequestsMetric.get()); - return false; - } - return true; -} - -void updateStatistics(const QueryStatsStore::Partition& proofOfLock, - QueryStatsEntry& toUpdate, - const uint64_t queryExecMicros, - const uint64_t firstResponseExecMicros, - const uint64_t docsReturned) { - toUpdate.latestSeenTimestamp = Date_t::now(); - toUpdate.lastExecutionMicros = queryExecMicros; - toUpdate.execCount++; - toUpdate.totalExecMicros.aggregate(queryExecMicros); - toUpdate.firstResponseExecMicros.aggregate(firstResponseExecMicros); - toUpdate.docsReturned.aggregate(docsReturned); -} - -} // namespace - -void registerRequest(OperationContext* opCtx, - const NamespaceString& collection, - std::function<std::unique_ptr<Key>(void)> makeKey, - bool willNeverExhaust) { - if (!isQueryStatsEnabled(opCtx->getServiceContext())) { - LOGV2_DEBUG(8473000, - 5, - "not collecting query stats for this request since it is disabled", - "featureEnabled"_attr = isQueryStatsFeatureEnabled()); - return; - } - - // Queries against metadata collections should never appear in queryStats data. - if (collection.isFLE2StateCollection()) { - return; - } - - // Don't record queries from internal clients. - if (opCtx->getClient()->session() && - (opCtx->getClient()->session()->getTags() & transport::Session::kInternalClient)) { - return; - } - - auto& opDebug = CurOp::get(opCtx)->debug(); - - if (opDebug.queryStatsInfo.wasRateLimited) { - LOGV2_DEBUG( - 8288900, - 4, - "Query stats request was previously rate limited. We expect this is a query on a view"); - return; - } - - if (!shouldCollect(opCtx->getServiceContext())) { - opDebug.queryStatsInfo.wasRateLimited = true; - return; - } - - if (opDebug.queryStatsInfo.key) { - // A find() request may have already registered the shapifier. Ie, it's a find command over - // a non-physical collection, eg view, which is implemented by generating an agg pipeline. - LOGV2_DEBUG(7198700, - 2, - "Query stats request shapifier already registered", - "collection"_attr = collection); - return; - } - - opDebug.queryStatsInfo.willNeverExhaust = willNeverExhaust; - // There are a few cases where a query shape can be larger than the original query. For example, - // {$exists: false} in the input query serializes to {$not: {$exists: true}. In rare cases where - // an input query has thousands of clauses, the cumulative bloat that shapification adds results - // in a BSON object that exceeds the 16 MB memory limit. In these cases, we want to exclude the - // original query from queryStats metrics collection and let it execute normally. - try { - opDebug.queryStatsInfo.key = makeKey(); - } catch (ExceptionFor<ErrorCodes::BSONObjectTooLarge>&) { - LOGV2_DEBUG(7979400, - 1, - "Query Stats shapification has exceeded the 16 MB memory limit. Metrics will " - "not be collected "); - queryStatsStoreWriteErrorsMetric.increment(); - return; - } - opDebug.queryStatsInfo.keyHash = absl::Hash<query_stats::Key>{}(*opDebug.queryStatsInfo.key); - // TODO look up this query shape (sub-component of query stats store key) in some new shared - // data structure that the query settings component could share. See if the query SHAPE hash has - // been computed before. If so, record the query shape hash on the opDebug. If not, compute the - // hash and store it there so we can avoid re-doing this for each request. -} - -QueryStatsStore& getQueryStatsStore(OperationContext* opCtx) { - uassert(ErrorCodes::QueryFeatureNotAllowed, - "Query stats is not enabled without the feature flag on and a cache size greater than " - "0 bytes", - isQueryStatsEnabled(opCtx->getServiceContext())); - return QueryStatsStoreManager::get(opCtx->getServiceContext())->getQueryStatsStore(); -} - -void writeQueryStats(OperationContext* opCtx, - boost::optional<size_t> queryStatsKeyHash, - std::unique_ptr<Key> key, - const uint64_t queryExecMicros, - const uint64_t firstResponseExecMicros, - const uint64_t docsReturned, - bool willNeverExhaust) { - // Generally we expect a 'key' to write query stats. However, for a change stream query, we - // expect it has no 'key' after its first writeQueryStats(), but it must have a - // 'queryStatsKeyHash' for its entry to be updated. - // TODO SERVER-89058 Modify comment to include tailable cursors. - if (!key && !(willNeverExhaust && queryStatsKeyHash)) { - return; - } - - // It's possible that query stats was enabled in registerRequest but has been disabled since - // (e.g., by FCV downgrade or setting the store size to 0). Rather than calling - // getQueryStatsStore (which would trigger a uassert if queryStats is disabled), we return and - // log a message if query stats is disabled, and otherwise grab the query stats store directly. - if (!isQueryStatsEnabled(opCtx->getServiceContext())) { - LOGV2_DEBUG(8456700, - 2, - "Query stats was enabled when the command started but is now disabled. " - "Metrics will not be collected.", - "queryStatsKeyHash"_attr = queryStatsKeyHash); - return; - } - auto&& queryStatsStore = - QueryStatsStoreManager::get(opCtx->getServiceContext())->getQueryStatsStore(); - if (key) { - dassert(absl::Hash<query_stats::Key>{}(*key) == queryStatsKeyHash, - "Expecting query stats key to hash to the given hash. Is the OpCtx state being " - "incorrectly re-used?"); - } - auto&& [statusWithMetrics, partitionLock] = - queryStatsStore.getWithPartitionLock(*queryStatsKeyHash); - if (statusWithMetrics.isOK()) { - // Found an existing entry! Just update the metrics and we're done. - return updateStatistics(partitionLock, - *statusWithMetrics.getValue(), - queryExecMicros, - firstResponseExecMicros, - docsReturned); - } - - // It is possible a cursor that lives forever has no key associated with it and its entry may - // have been evicted. - if (willNeverExhaust && !key) { - return; - } - - // Otherwise we didn't find an existing entry. Try to create one. - tassert(7315200, - "key cannot be null when writing a new entry to the queryStats store", - key != nullptr); - size_t numEvicted = - queryStatsStore.put(*queryStatsKeyHash, QueryStatsEntry(std::move(key)), partitionLock); - queryStatsEvictedMetric.increment(numEvicted); - auto newMetrics = partitionLock->get(*queryStatsKeyHash); - if (!newMetrics.isOK()) { - // This can happen if the budget is immediately exceeded. Specifically if the there is - // not enough room for a single new entry if the number of partitions is too high - // relative to the size. - queryStatsStoreWriteErrorsMetric.increment(); - LOGV2_DEBUG(7560900, - 0, - "Failed to store queryStats entry.", - "status"_attr = newMetrics.getStatus(), - "queryStatsKeyHash"_attr = queryStatsKeyHash); - return; - } - - return updateStatistics(partitionLock, - newMetrics.getValue()->second, - queryExecMicros, - firstResponseExecMicros, - docsReturned); -} - -void writeQueryStatsOnCursorDisposeOrKill(OperationContext* opCtx, - boost::optional<size_t> queryStatsKeyHash, - std::unique_ptr<Key> key, - bool willNeverExhaust, - const uint64_t queryExecMicros, - const uint64_t firstResponseExecMicros, - const uint64_t docsReturned) { - // It is discouraged but technically possible for a user to enable queryStats on the mongods of - // a replica set. In this case, a cursor will be created for each mongod. However, the - // queryStatsKey is behind a unique_ptr on CurOp. The ClientCursor constructor std::moves the - // queryStatsKey so it uniquely owns it (and also makes the queryStatsKey on CurOp now a - // nullptr) and copies over the queryStatsKeyHash as the latter is a cheap copy. - // In the case of sharded $search, two cursors will be created per mongod. In this way, - // two cursors are part of the same thread/operation, and therefore share a OpCtx/CurOp/OpDebug. - // The first cursor that is created will own the queryStatsKey and have a copy of the - // queryStatsKeyHash. On the other hand, the second one will only have a copy of the hash since - // the queryStatsKey will be null on CurOp from being std::move'd in the first cursor - // construction call. To not trip the tassert in writeQueryStats and because all cursors are - // guaranteed to have a copy of the hash, we check that the cursor has a key - if (key && opCtx) { - query_stats::writeQueryStats(opCtx, - queryStatsKeyHash, - std::move(key), - queryExecMicros, - firstResponseExecMicros, - docsReturned, - willNeverExhaust); - } else if (willNeverExhaust && opCtx) { - // Since we already recorded information about the possible getMores associated with a - // cursor that never ends, the only information left to record is about the kill/dispose - // cursor operation. This operation is not timed and does not have any metrics associated - // with it. - query_stats::writeQueryStats(opCtx, queryStatsKeyHash, nullptr, 0, 0, 0, willNeverExhaust); - } -} - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats.h b/src/mongo/db/query/query_stats/query_stats.h deleted file mode 100644 index fc96a8be179..00000000000 --- a/src/mongo/db/query/query_stats/query_stats.h +++ /dev/null @@ -1,211 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - -#pragma once - -#include "mongo/base/status.h" -#include "mongo/bson/bsonobj.h" -#include "mongo/db/concurrency/d_concurrency.h" -#include "mongo/db/curop.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/query/partitioned_cache.h" -#include "mongo/db/query/plan_explainer.h" -#include "mongo/db/query/query_stats/key.h" -#include "mongo/db/query/query_stats/query_stats_entry.h" -#include "mongo/db/query/query_stats/rate_limiting.h" -#include "mongo/db/service_context.h" -#include "mongo/db/views/view.h" -#include <cstdint> -#include <memory> - -namespace mongo::query_stats { - -extern Counter64 queryStatsStoreSizeEstimateBytesMetric; - -struct QueryStatsPartitioner { - // The partitioning function for use with the 'Partitioned' utility. - std::size_t operator()(const std::size_t hash, const std::size_t nPartitions) const { - return hash % nPartitions; - } -}; - -struct QueryStatsStoreEntryBudgetor { - size_t operator()(const std::size_t hash, const QueryStatsEntry& value) { - return sizeof(decltype(value)) + sizeof(decltype(hash)) + value.key->size(); - } -}; - -/* - * 'QueryStatsStore insertion and eviction listener implementation. This class adjusts the - * 'queryStatsStoreSize' serverStatus metric when entries are inserted or evicted. - */ -struct QueryStatsStoreInsertionEvictionListener { - void onInsert(const std::size_t&, const QueryStatsEntry&, size_t estimatedSize) { - queryStatsStoreSizeEstimateBytesMetric.increment(estimatedSize); - } - - void onEvict(const std::size_t&, const QueryStatsEntry&, size_t estimatedSize) { - queryStatsStoreSizeEstimateBytesMetric.decrement(estimatedSize); - } - - void onClear(size_t estimatedSize) { - queryStatsStoreSizeEstimateBytesMetric.decrement(estimatedSize); - } -}; -using QueryStatsStore = PartitionedCache<std::size_t, - QueryStatsEntry, - QueryStatsStoreEntryBudgetor, - QueryStatsPartitioner, - QueryStatsStoreInsertionEvictionListener>; - -/** - * A manager for the queryStats store allows a "pointer swap" on the queryStats store itself. The - * usage patterns are as follows: - * - * - Updating the queryStats store uses the `getQueryStatsStore()` method. The queryStats store - * instance is obtained, entries are looked up and mutated, or created anew. - * - The queryStats store is "reset". This involves atomically allocating a new instance, once - * there are no more updaters (readers of the store "pointer"), and returning the existing - * instance. - */ -class QueryStatsStoreManager { -public: - // The query stats store can be configured using these objects on a per-ServiceContext level. - // This is essentially global, but can be manipulated by unit tests. - static const ServiceContext::Decoration<std::unique_ptr<QueryStatsStoreManager>> get; - static const ServiceContext::Decoration<std::unique_ptr<RateLimiting>> getRateLimiter; - - template <typename... QueryStatsStoreArgs> - QueryStatsStoreManager(size_t cacheSize, size_t numPartitions) - : _queryStatsStore(std::make_unique<QueryStatsStore>(cacheSize, numPartitions)), - _maxSize(cacheSize) {} - - /** - * Acquire the instance of the queryStats store. - */ - QueryStatsStore& getQueryStatsStore() { - return *_queryStatsStore; - } - - size_t getMaxSize() { - return _maxSize.load(); - } - - /** - * Resize the queryStats store and return the number of evicted - * entries. - */ - size_t resetSize(size_t cacheSize) { - _maxSize.store(cacheSize); - return _queryStatsStore->reset(cacheSize); - } - -private: - std::unique_ptr<QueryStatsStore> _queryStatsStore; - - /** - * Max size of the queryStats store. Tracked here to avoid having to recompute after it's - * divided up into partitions. - */ - AtomicWord<size_t> _maxSize; -}; - -/** - * Acquire a reference to the global queryStats store. - */ -QueryStatsStore& getQueryStatsStore(OperationContext* opCtx); - -/** - * Registers a request for query stats collection. The function may decide not to collect anything, - * so this should be called for all requests. The decision is made based on the feature flag and - * query stats rate limiting. - * - * The originating command/query does not persist through the end of query execution due to - * optimizations made to the original query and the expiration of OpCtx across getMores. In order - * to pair the query stats metrics that are collected at the end of execution with the original - * query, it is necessary to store the original query during planning and persist it through - * getMores. - * - * During planning, registerRequest is called to serialize the query stats key and save it to - * OpDebug. If a query's execution is complete within the original operation, - * collectQueryStatsMongod/collectQueryStatsMongos will call writeQueryStats() and pass along the - * query stats key to be saved in the query stats store alongside metrics collected. - * - * However, OpDebug does not persist through cursor iteration, so if a query's execution will span - * more than one request/operation, it's necessary to save the query stats context to the cursor - * upon cursor registration. In these cases, collectQueryStatsMongod/collectQueryStatsMongos will - * aggregate each operation's metrics within the cursor. Once the request is eventually complete, - * the cursor calls writeQueryStats() on its destruction. - * - * Notes: - * - It's important to call registerRequest with the original request, before canonicalizing or - * optimizing it, in order to preserve the user's input for the query shape. - * - Calling this affects internal state. It should be called exactly once for each request for - * which query stats may be collected. - * - The std::function argument to construct an abstracted Key is provided to break - * library cycles so this library does not need to know how to parse everything. It is done as a - * deferred construction callback to ensure that this feature does not impact performance if - * collecting stats is not needed due to the feature being disabled or the request being rate - * limited. - */ -void registerRequest(OperationContext* opCtx, - const NamespaceString& collection, - std::function<std::unique_ptr<Key>(void)> makeKey, - bool willNeverExhaust = false); - -/** - * Writes query stats to the query stats store for the operation identified by `queryStatsKeyHash`. - * - * Direct calls to writeQueryStats in new code should be avoided in favor of calling existing - * functions: - * - collectQueryStatsMongod/collectQueryStatsMongos in the case of requests that span one - * operation - * - writeQueryStatsOnCursorDisposeOrKill() in the case of requests that span - * multiple operations (via getMore) - */ -void writeQueryStats(OperationContext* opCtx, - boost::optional<size_t> queryStatsKeyHash, - std::unique_ptr<Key> key, - uint64_t queryExecMicros, - uint64_t firstResponseExecMicros, - uint64_t docsReturned, - bool willNeverExhaust = false); - -/** - * Called from ClientCursor::dispose/ClusterClientCursorImpl::kill to set up and writeQueryStats() - * at the end of life of a cursor. - */ -void writeQueryStatsOnCursorDisposeOrKill(OperationContext* opCtx, - boost::optional<size_t> queryStatsKeyHash, - std::unique_ptr<Key> key, - bool willNeverExhaust, - uint64_t queryExecMicros, - uint64_t firstResponseExecMicros, - uint64_t docsReturned); -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats_entry.cpp b/src/mongo/db/query/query_stats/query_stats_entry.cpp deleted file mode 100644 index f69f0a6ee2a..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_entry.cpp +++ /dev/null @@ -1,54 +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 "mongo/db/query/query_stats/query_stats_entry.h" - -#include <boost/optional.hpp> - -#include "mongo/crypto/hash_block.h" -#include "mongo/crypto/sha256_block.h" - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -namespace mongo::query_stats { - -BSONObj QueryStatsEntry::toBSON() const { - BSONObjBuilder builder{sizeof(QueryStatsEntry) + 100}; - builder.append("lastExecutionMicros", (long long)lastExecutionMicros); - builder.append("execCount", (long long)execCount); - totalExecMicros.appendTo(builder, "totalExecMicros"); - firstResponseExecMicros.appendTo(builder, "firstResponseExecMicros"); - docsReturned.appendTo(builder, "docsReturned"); - builder.append("firstSeenTimestamp", firstSeenTimestamp); - builder.append("latestSeenTimestamp", latestSeenTimestamp); - return builder.obj(); -} - - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats_entry.h b/src/mongo/db/query/query_stats/query_stats_entry.h deleted file mode 100644 index 6b61a6a6dcf..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_entry.h +++ /dev/null @@ -1,95 +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. - */ - -#pragma once - -#include <algorithm> -#include <cstdint> -#include <memory> - -#include "mongo/db/commands/server_status_metric.h" -#include "mongo/db/query/query_stats/aggregated_metric.h" -#include "mongo/db/query/query_stats/key.h" -#include "mongo/db/query/query_stats/transform_algorithm_gen.h" -#include "mongo/util/time_support.h" - -namespace mongo::query_stats { - -/** - * The value stored in the query stats store. It contains a Key representing this "kind" of - * query, and some metrics about that shape. This class is responsible for knowing its size and - * updating our server status metrics about the size of the query stats store accordingly. At the - * time of this writing, the LRUCache utility does not easily expose its size in a way we could use - * as server status metrics. - */ -struct QueryStatsEntry { - QueryStatsEntry(std::unique_ptr<const Key> key_) - : firstSeenTimestamp(Date_t::now()), key(std::move(key_)) {} - - BSONObj toBSON() const; - - /** - * Timestamp for when this query shape was added to the store. Set on construction. - */ - const Date_t firstSeenTimestamp; - - /** - * Timestamp for when the latest time this query shape was seen. - */ - Date_t latestSeenTimestamp; - - /** - * Last execution time in microseconds. - */ - uint64_t lastExecutionMicros = 0; - - /** - * Number of query executions. - */ - uint64_t execCount = 0; - - /** - * Aggregates the total time for execution including getMore requests. - */ - AggregatedMetric totalExecMicros; - - /** - * Aggregates the time for execution for first batch only. - */ - AggregatedMetric firstResponseExecMicros; - - AggregatedMetric docsReturned; - - /** - * The Key that can generate the query stats key for this request. - */ - std::shared_ptr<const Key> key; -}; - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats_helpers.h b/src/mongo/db/query/query_stats/query_stats_helpers.h deleted file mode 100644 index 6d53cc8d4ce..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_helpers.h +++ /dev/null @@ -1,52 +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. - */ - -#pragma once - -#include <absl/hash/hash.h> -#include <boost/optional.hpp> - -#include "mongo/bson/bsonobj.h" -#include "mongo/bson/simple_bsonobj_comparator.h" -#include "mongo/db/query/query_shape/shape_helpers.h" - -namespace mongo::query_stats { - -/** - * An abseil compatible hash function for BSONObjects. Note that this hasher ignores any collation - * and uses the "simple" comparisons. This is fine and correct for query stats, but this is - * intentionally placed within the 'query_stats' namespace to avoid polluting the whole codebase - * with this helper which could cause an accidental bug where we ignore the request's collation. - */ -template <typename H> -H AbslHashValue(H h, const BSONObj& obj) { - return H::combine(std::move(h), simpleHash(obj)); -} - -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats_on_parameter_change.cpp b/src/mongo/db/query/query_stats/query_stats_on_parameter_change.cpp deleted file mode 100644 index a8b7df9fccb..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_on_parameter_change.cpp +++ /dev/null @@ -1,97 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -#include "mongo/db/query/query_stats/query_stats_on_parameter_change.h" - -#include "mongo/base/status.h" -#include "mongo/db/concurrency/d_concurrency.h" -#include "mongo/db/query/partitioned_cache.h" -#include "mongo/db/query/query_knobs_gen.h" -#include "mongo/db/query/util/memory_util.h" -#include "mongo/db/service_context.h" -#include "mongo/logv2/log.h" - -namespace mongo::query_stats_util { - -namespace { -/** - * Given the current 'Client', returns a pointer to the 'ServiceContext' and an interface for - * updating the queryStats store. - */ -std::pair<ServiceContext*, OnParamChangeUpdater*> getUpdater(const Client& client) { - auto serviceCtx = client.getServiceContext(); - tassert(7106500, "ServiceContext must be non null", serviceCtx); - - auto updater = queryStatsStoreOnParamChangeUpdater(serviceCtx).get(); - tassert(7106501, "queryStats store size updater must be non null", updater); - return {serviceCtx, updater}; -} -} // namespace - - -Status onQueryStatsStoreSizeUpdate(const std::string& str) { - auto newSize = memory_util::MemorySize::parse(str); - if (!newSize.isOK()) { - return newSize.getStatus(); - } - - // The client is nullptr if the parameter is supplied from the command line. In this case, we - // ignore the update event, the parameter will be processed when initializing the service - // context. - if (auto client = Client::getCurrent()) { - auto&& [serviceCtx, updater] = getUpdater(*client); - updater->updateCacheSize(serviceCtx, newSize.getValue()); - } - - return Status::OK(); -} - -Status validateQueryStatsStoreSize(const std::string& str) { - return memory_util::MemorySize::parse(str).getStatus(); -} - -Status onQueryStatsSamplingRateUpdate(int samplingRate) { - // The client is nullptr if the parameter is supplied from the command line. In this case, we - // ignore the update event, the parameter will be processed when initializing the service - // context. - if (auto client = Client::getCurrent()) { - auto&& [serviceCtx, updater] = getUpdater(*client); - updater->updateSamplingRate(serviceCtx, samplingRate < 0 ? INT_MAX : samplingRate); - } - - return Status::OK(); -} - -const Decorable<ServiceContext>::Decoration<std::unique_ptr<OnParamChangeUpdater>> - queryStatsStoreOnParamChangeUpdater = - ServiceContext::declareDecoration<std::unique_ptr<OnParamChangeUpdater>>(); -} // namespace mongo::query_stats_util diff --git a/src/mongo/db/query/query_stats/query_stats_on_parameter_change.h b/src/mongo/db/query/query_stats/query_stats_on_parameter_change.h deleted file mode 100644 index 2a824961b34..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_on_parameter_change.h +++ /dev/null @@ -1,76 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - -#pragma once - -#include "mongo/base/status.h" -#include "mongo/db/concurrency/d_concurrency.h" -#include "mongo/db/query/partitioned_cache.h" -#include "mongo/db/query/util/memory_util.h" - - -namespace mongo::query_stats_util { - -Status onQueryStatsStoreSizeUpdate(const std::string& str); - - -Status validateQueryStatsStoreSize(const std::string& str); - -Status onQueryStatsSamplingRateUpdate(int samplingRate); - -/** - * An interface used to modify the queryStats store when query setParameters are modified. This is - * done via an interface decorating the 'ServiceContext' in order to avoid a link-time dependency of - * the query knobs library on the queryStats code. - */ -class OnParamChangeUpdater { -public: - virtual ~OnParamChangeUpdater() = default; - - /** - * Resizes the queryStats store decorating 'serviceCtx' to the new size given by 'memSize'. If - * the new size is smaller than the old, cache entries are evicted in order to ensure the - * cache fits within the new size bound. - */ - virtual void updateCacheSize(ServiceContext* serviceCtx, memory_util::MemorySize memSize) = 0; - - /** - * Updates the sampling rate for the queryStats rate limiter. - */ - virtual void updateSamplingRate(ServiceContext* serviceCtx, int samplingRate) = 0; -}; - -/** - * Decorated accessor to the 'OnParamChangeUpdater' stored in 'ServiceContext'. Again, this is done - * via a decoration and interface to avoid a link-time dependency from the query knobs library on - * the queryStats code. - */ -extern const Decorable<ServiceContext>::Decoration<std::unique_ptr<OnParamChangeUpdater>> - queryStatsStoreOnParamChangeUpdater; -} // namespace mongo::query_stats_util diff --git a/src/mongo/db/query/query_stats/query_stats_store_test.cpp b/src/mongo/db/query/query_stats/query_stats_store_test.cpp deleted file mode 100644 index 90cb073eafc..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_store_test.cpp +++ /dev/null @@ -1,1406 +0,0 @@ -/** - * Copyright (C) 2022-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 "mongo/bson/simple_bsonobj_comparator.h" -#include "mongo/db/catalog/rename_collection.h" -#include "mongo/db/collection_type.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_feature_flags_gen.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_shape/serialization_options.h" -#include "mongo/db/query/query_stats/agg_key.h" -#include "mongo/db/query/query_stats/find_key.h" -#include "mongo/db/query/query_stats/key.h" -#include "mongo/db/query/query_stats/query_stats.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/idl/server_parameter_test_util.h" -#include "mongo/unittest/unittest.h" - -namespace mongo::query_stats { - -int countAllEntries(const QueryStatsStore& store) { - int numKeys = 0; - store.forEach([&](auto&& key, auto&& entry) { numKeys++; }); - return numKeys; -} - -static const NamespaceStringOrUUID kDefaultTestNss = NamespaceString("testDB.testColl"); -class QueryStatsStoreTest : public ServiceContextTest { -public: - static std::unique_ptr<const Key> makeFindKeyFromQuery(BSONObj filter) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto fcr = std::make_unique<FindCommandRequest>(kDefaultTestNss); - fcr->setFilter(filter.getOwned()); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, std::move(fcr))); - return std::make_unique<FindKey>(expCtx, *parsedFind, collectionType); - } - - static constexpr auto collectionType = query_shape::CollectionType::kCollection; - BSONObj makeQueryStatsKeyFindRequest(const FindCommandRequest& fcr, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - bool applyHmac) { - auto fcrCopy = std::make_unique<FindCommandRequest>(fcr); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, std::move(fcrCopy))); - FindKey findKey(expCtx, *parsedFind, collectionType); - SerializationOptions opts = SerializationOptions::kDebugShapeAndMarkIdentifiers_FOR_TEST; - if (!applyHmac) { - opts.transformIdentifiers = false; - opts.transformIdentifiersCallback = defaultHmacStrategy; - } - return findKey.toBson(expCtx->opCtx, opts); - } - - BSONObj makeQueryStatsKeyAggregateRequest(AggregateCommandRequest acr, - const Pipeline& pipeline, - const boost::intrusive_ptr<ExpressionContext>& expCtx, - LiteralSerializationPolicy literalPolicy, - bool applyHmac = false) { - auto aggKey = std::make_unique<AggKey>(acr, - pipeline, - expCtx, - pipeline.getInvolvedCollections(), - acr.getNamespace(), - collectionType); - - // SerializationOptions opts{.literalPolicy = literalPolicy}; - SerializationOptions opts = SerializationOptions::kMarkIdentifiers_FOR_TEST; - opts.literalPolicy = literalPolicy; - if (!applyHmac) { - opts.transformIdentifiers = false; - opts.transformIdentifiersCallback = defaultHmacStrategy; - } - return aggKey->toBson(expCtx->opCtx, opts); - } -}; - -TEST_F(QueryStatsStoreTest, BasicUsage) { - QueryStatsStore queryStatsStore{5000000, 1000}; - - auto getMetrics = [&](BSONObj query) { - auto key = makeFindKeyFromQuery(query); - auto lookupResult = queryStatsStore.lookup(absl::Hash<query_stats::Key>{}(*key)); - ASSERT_OK(lookupResult); - return *lookupResult.getValue(); - }; - - auto collectMetrics = [&](BSONObj query) { - auto key = makeFindKeyFromQuery(query); - auto lookupHash = absl::Hash<query_stats::Key>{}(*key); - auto lookupResult = queryStatsStore.lookup(lookupHash); - if (!lookupResult.isOK()) { - queryStatsStore.put(lookupHash, QueryStatsEntry{std::move(key)}); - lookupResult = queryStatsStore.lookup(lookupHash); - } - auto metrics = lookupResult.getValue(); - metrics->execCount += 1; - metrics->lastExecutionMicros += 123456; - }; - - auto query1 = BSON("query" << 1 << "xEquals" << 42); - // same value, different instance (tests hashing & equality) - auto query1x = BSON("query" << 1 << "xEquals" << 42); - auto query2 = BSON("query" << 2 << "yEquals" << 43); - - collectMetrics(query1); - collectMetrics(query1); - collectMetrics(query1x); - collectMetrics(query2); - - ASSERT_EQ(getMetrics(query1).execCount, 3); - ASSERT_EQ(getMetrics(query1x).execCount, 3); - ASSERT_EQ(getMetrics(query2).execCount, 1); - - auto collectMetricsWithLock = [&](BSONObj& filter) { - auto key = makeFindKeyFromQuery(filter); - auto [lookupResult, lock] = - queryStatsStore.getWithPartitionLock(absl::Hash<query_stats::Key>{}(*key)); - ASSERT_OK(lookupResult); - auto& metrics = *lookupResult.getValue(); - metrics.execCount += 1; - metrics.lastExecutionMicros += 123456; - }; - - collectMetricsWithLock(query1x); - collectMetricsWithLock(query2); - - ASSERT_EQ(getMetrics(query1).execCount, 4); - ASSERT_EQ(getMetrics(query1x).execCount, 4); - ASSERT_EQ(getMetrics(query2).execCount, 2); - - ASSERT_EQ(2, countAllEntries(queryStatsStore)); -} - -TEST_F(QueryStatsStoreTest, EvictionTest) { - // This creates a queryStats store with a single partition to specifically test the eviction - // behavior with very large queries. - // Add an entry that is smaller than the max partition size. - auto query = BSON("query" << 1 << "xEquals" << 42); - auto key = makeFindKeyFromQuery(query); - - const size_t cacheSize = key->size() + sizeof(QueryStatsEntry) + 100; - const auto numPartitions = 1; - QueryStatsStore queryStatsStore{cacheSize, numPartitions}; - - auto hash = absl::Hash<query_stats::Key>{}(*key); - queryStatsStore.put(hash, QueryStatsEntry{std::move(key)}); - ASSERT_EQ(countAllEntries(queryStatsStore), 1); - - // We'll do this again later so save this as a helper function. - auto addLargeEntry = [&](auto& queryStatsStore) { - // Add an entry that is larger than the max partition size to the non-empty partition. This - // should evict both entries, the first small entry written to the partition and the current - // too large entry we wish to write to the partition. The reason is because entries are - // evicted from the partition in order of least recently used. Thus, the small entry will be - // evicted first but the partition will still be over budget so the final, too large entry - // will also be evicted. - auto opCtx = makeOperationContext(); - auto fcr = std::make_unique<FindCommandRequest>( - NamespaceStringOrUUID(NamespaceString("testDB.testColl"))); - fcr->setLet(BSON("var" << 2)); - fcr->setFilter(fromjson("{$expr: [{$eq: ['$a', '$$var']}]}")); - fcr->setProjection(fromjson("{varIs: '$$var'}")); - fcr->setLimit(5); - fcr->setSkip(2); - fcr->setBatchSize(25); - fcr->setMaxTimeMS(1000); - fcr->setNoCursorTimeout(false); - opCtx->setComment(BSON("comment" - << " foo bar baz")); - fcr->setSingleBatch(false); - fcr->setAllowDiskUse(false); - fcr->setAllowPartialResults(true); - fcr->setAllowDiskUse(false); - fcr->setShowRecordId(true); - fcr->setHint(BSON("z" << 1 << "c" << 1)); - fcr->setMax(BSON("z" << 25)); - fcr->setMin(BSON("z" << 80)); - fcr->setSort(BSON("sortVal" << 1 << "otherSort" << -1)); - auto&& [expCtx, parsedFind] = - uassertStatusOK(parsed_find_command::parse(opCtx.get(), std::move(fcr))); - - key = std::make_unique<query_stats::FindKey>(expCtx, *parsedFind, collectionType); - auto lookupHash = absl::Hash<query_stats::Key>{}(*key); - QueryStatsEntry testMetrics{std::move(key)}; - queryStatsStore.put(lookupHash, testMetrics); - }; - - addLargeEntry(queryStatsStore); - ASSERT_EQ(countAllEntries(queryStatsStore), 0); - - // This creates a queryStats store where each partition has a max size of 500 bytes. - QueryStatsStore queryStatsStoreTwo{/*cacheSize*/ cacheSize * 3, /*numPartitions*/ 3}; - // Adding a queryStats store entry that is smaller than the overal cache size but larger - // than a single partition max size, will cause an eviction. testMetrics is larger than 500 - // bytes and thus over budget for the partitions of this cache. - addLargeEntry(queryStatsStoreTwo); - ASSERT_EQ(countAllEntries(queryStatsStoreTwo), 0); -} - -TEST_F(QueryStatsStoreTest, GenerateMaxBsonSizeQueryShape) { - const NamespaceString nss = NamespaceString("testDB.testColl"); - FindCommandRequest fcr((NamespaceStringOrUUID(nss))); - // This creates a query that is just below the 16 MB memory limit. - int limit = 225500; - BSONObjBuilder bob; - BSONArrayBuilder andBob(bob.subarrayStart("$and")); - for (int i = 1; i <= limit; i++) { - BSONObjBuilder childrenBob; - childrenBob.append("x", BSON("$lt" << i << "$gte" << i)); - andBob.append(childrenBob.obj()); - } - andBob.doneFast(); - fcr.setFilter(bob.obj()); - auto fcrCopy = std::make_unique<FindCommandRequest>(fcr); - auto opCtx = makeOperationContext(); - auto parsedFindPair = - uassertStatusOK(parsed_find_command::parse(opCtx.get(), std::move(fcrCopy))); - - auto&& globalQueryStatsStoreManager = QueryStatsStoreManager::get(opCtx->getServiceContext()); - globalQueryStatsStoreManager = std::make_unique<QueryStatsStoreManager>(500000, 1000); - - // The shapification process will bloat the input query over the 16 MB memory limit. Assert that - // calling registerRequest() doesn't throw and that the opDebug isn't registered with a key hash - // (thus metrics won't be tracked for this query). - ASSERT_DOES_NOT_THROW(query_stats::registerRequest(opCtx.get(), nss, [&]() { - return std::make_unique<query_stats::FindKey>( - parsedFindPair.first, *parsedFindPair.second, query_shape::CollectionType::kCollection); - })); - auto& opDebug = CurOp::get(*opCtx)->debug(); - ASSERT_FALSE(opDebug.queryStatsInfo.keyHash.has_value()); -} - -TEST_F(QueryStatsStoreTest, CorrectlyRedactsFindCommandRequestAllFields) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - FindCommandRequest fcr(kDefaultTestNss); - - fcr.setFilter(BSON("a" << 1)); - - auto key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - } - }, - "collectionType": "collection" - })", - key); - - // Add sort. - fcr.setSort(BSON("sortVal" << 1 << "otherSort" << -1)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - } - }, - "collectionType": "collection" - })", - key); - - // Add inclusion projection. - fcr.setProjection(BSON("e" << true << "f" << true)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - } - }, - "collectionType": "collection" - })", - key); - - // Add let. - fcr.setLet(BSON("var1" << 1 << "var2" - << "const1")); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var1>": "?number", - "HASH<var2>": "?string" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - } - }, - "collectionType": "collection" - })", - key); - - // Add hinting fields. - fcr.setHint(BSON("z" << 1 << "c" << 1)); - fcr.setMax(BSON("z" << 25)); - fcr.setMin(BSON("z" << 80)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var1>": "?number", - "HASH<var2>": "?string" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - } - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - } - })", - key); - - // Add the literal redaction fields. - fcr.setLimit(5); - fcr.setSkip(2); - fcr.setBatchSize(25); - fcr.setMaxTimeMS(1000); - fcr.setNoCursorTimeout(false); - - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var1>": "?number", - "HASH<var2>": "?string" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - }, - "limit": "?number", - "skip": "?number" - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - }, - "maxTimeMS": "?number", - "noCursorTimeout": false, - "batchSize": "?number" - })", - key); - - // Add the fields that shouldn't be hmacApplied. - fcr.setSingleBatch(true); - fcr.setAllowDiskUse(false); - fcr.setAllowPartialResults(true); - fcr.setAllowDiskUse(false); - fcr.setShowRecordId(true); - auto readPreference = BSON("mode" - << "nearest" - << "tags" - << BSON_ARRAY(BSON("some" - << "tag") - << BSON("some" - << "other tag"))); - ReadPreferenceSetting::get(expCtx->opCtx) = - uassertStatusOK(ReadPreferenceSetting::fromInnerBSON(readPreference)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var1>": "?number", - "HASH<var2>": "?string" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - }, - "limit": "?number", - "skip": "?number", - "singleBatch": true, - "allowDiskUse": false, - "showRecordId": true - }, - "$readPreference": { - "mode": "nearest", - "tags": [ { "some": "other tag" }, { "some": "tag" } ], - "hedge": { "enabled": true } - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - }, - "maxTimeMS": "?number", - "allowPartialResults": true, - "noCursorTimeout": false, - "batchSize": "?number" - })", - key); - - fcr.setAllowPartialResults(false); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - // Make sure that a false allowPartialResults is also accurately captured. - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var1>": "?number", - "HASH<var2>": "?string" - }, - "command": "find", - "filter": { - "HASH<a>": { - "$eq": "?number" - } - }, - "projection": { - "HASH<e>": true, - "HASH<f>": true, - "HASH<_id>": true - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - }, - "sort": { - "HASH<sortVal>": 1, - "HASH<otherSort>": -1 - }, - "limit": "?number", - "skip": "?number", - "singleBatch": true, - "allowDiskUse": false, - "showRecordId": true - }, - "$readPreference": { - "mode": "nearest", - "tags": [ { "some": "other tag" }, { "some": "tag" } ], - "hedge": { "enabled": true } - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - }, - "maxTimeMS": "?number", - "allowPartialResults": false, - "noCursorTimeout": false, - "batchSize": "?number" - })", - key); -} - -TEST_F(QueryStatsStoreTest, CorrectlyRedactsTailableFindCommandRequest) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - - FindCommandRequest fcr(NamespaceStringOrUUID(NamespaceString("testDB.testColl"))); - fcr.setAwaitData(true); - fcr.setTailable(true); - fcr.setSort(BSON("$natural" << 1)); - auto key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": {}, - "tailable": true, - "awaitData": true - }, - "collectionType": "collection", - "hint": { - "$natural": 1 - } - })", - key); -} - -TEST_F(QueryStatsStoreTest, CorrectlyRedactsFindCommandRequestEmptyFields) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - FindCommandRequest fcr(NamespaceStringOrUUID(NamespaceString("testDB.testColl"))); - fcr.setFilter(BSONObj()); - fcr.setSort(BSONObj()); - fcr.setProjection(BSONObj()); - - auto hmacApplied = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": {} - }, - "collectionType": "collection" - })", - hmacApplied); // NOLINT (test auto-update) -} - -TEST_F(QueryStatsStoreTest, CorrectlyRedactsHintsWithOptions) { - auto expCtx = make_intrusive<ExpressionContextForTest>(); - FindCommandRequest fcr(NamespaceStringOrUUID(NamespaceString("testDB.testColl"))); - - fcr.setFilter(BSON("b" << 1)); - fcr.setHint(BSON("z" << 1 << "c" << 1)); - fcr.setMax(BSON("z" << 25)); - fcr.setMin(BSON("z" << 80)); - - auto key = makeQueryStatsKeyFindRequest(fcr, expCtx, false); - - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "command": "find", - "filter": { - "b": { - "$eq": "?number" - } - }, - "max": { - "z": "?number" - }, - "min": { - "z": "?number" - } - }, - "collectionType": "collection", - "hint": { - "z": 1, - "c": 1 - } - })", - key); - // Test with a string hint. Note that this is the internal representation of the string hint - // generated at parse time. - fcr.setHint(BSON("$hint" - << "z")); - - key = makeQueryStatsKeyFindRequest(fcr, expCtx, false); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "command": "find", - "filter": { - "b": { - "$eq": "?number" - } - }, - "max": { - "z": "?number" - }, - "min": { - "z": "?number" - } - }, - "collectionType": "collection", - "hint": { - "$hint": "z" - } - })", - key); - - fcr.setHint(BSON("z" << 1 << "c" << 1)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": { - "HASH<b>": { - "$eq": "?number" - } - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - } - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - } - })", - key); - - // Test that $natural comes through unmodified. - fcr.setHint(BSON("$natural" << -1)); - key = makeQueryStatsKeyFindRequest(fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "find", - "filter": { - "HASH<b>": { - "$eq": "?number" - } - }, - "max": { - "HASH<z>": "?number" - }, - "min": { - "HASH<z>": "?number" - } - }, - "collectionType": "collection", - "hint": { - "$natural": -1 - } - })", - key); -} - -TEST_F(QueryStatsStoreTest, DefinesLetVariables) { - // Test that the expression context we use to apply hmac will understand the 'let' part of - // the find command while parsing the other pieces of the command. - - // Note that this ExpressionContext will not have the let variables defined - we expect the - // 'makeQueryStatsKey' call to do that. - auto opCtx = makeOperationContext(); - auto fcr = std::make_unique<FindCommandRequest>(NamespaceString("testDB.testColl")); - fcr->setLet(BSON("var" << 2)); - fcr->setFilter(fromjson("{$expr: [{$eq: ['$a', '$$var']}]}")); - fcr->setProjection(fromjson("{varIs: '$$var'}")); - - auto expCtx = make_intrusive<ExpressionContextForTest>(opCtx.get()); - expCtx->variables.seedVariablesWithLetParameters(expCtx.get(), *fcr->getLet()); - auto hmacApplied = makeQueryStatsKeyFindRequest(*fcr, expCtx, false); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "testDB", - "coll": "testColl" - }, - "let": { - "var": "?number" - }, - "command": "find", - "filter": { - "$expr": [ - { - "$eq": [ - "$a", - "$$var" - ] - } - ] - }, - "projection": { - "varIs": "$$var", - "_id": true - } - }, - "collectionType": "collection" - })", - hmacApplied); - - hmacApplied = makeQueryStatsKeyFindRequest(*fcr, expCtx, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "let": { - "HASH<var>": "?number" - }, - "command": "find", - "filter": { - "$expr": [ - { - "$eq": [ - "$HASH<a>", - "$$HASH<var>" - ] - } - ] - }, - "projection": { - "HASH<varIs>": "$$HASH<var>", - "HASH<_id>": true - } - }, - "collectionType": "collection" - })", - hmacApplied); -} - -TEST_F(QueryStatsStoreTest, CorrectlyTokenizesAggregateCommandRequestAllFieldsSimplePipeline) { - auto expCtx = make_intrusive<ExpressionContextForTest>(*kDefaultTestNss.nss()); - AggregateCommandRequest acr(*kDefaultTestNss.nss()); - auto matchStage = fromjson(R"({ - $match: { - foo: { $in: ["a", "b"] }, - bar: { $gte: { $date: "2022-01-01T00:00:00Z" } } - } - })"); - auto unwindStage = fromjson("{$unwind: '$x'}"); - auto groupStage = fromjson(R"({ - $group: { - _id: "$_id", - c: { $first: "$d.e" }, - f: { $sum: 1 } - } - })"); - auto limitStage = fromjson("{$limit: 10}"); - auto outStage = fromjson(R"({$out: 'outColl'})"); - auto rawPipeline = {matchStage, unwindStage, groupStage, limitStage, outStage}; - acr.setPipeline(rawPipeline); - auto pipeline = Pipeline::parse(rawPipeline, expCtx); - - auto shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "HASH<foo>": { - "$in": "?array<?string>" - } - }, - { - "HASH<bar>": { - "$gte": "?date" - } - } - ] - } - }, - { - "$unwind": { - "path": "$HASH<x>" - } - }, - { - "$group": { - "_id": "$HASH<_id>", - "HASH<c>": { - "$first": "$HASH<d>.HASH<e>" - }, - "HASH<f>": { - "$sum": "?number" - } - } - }, - { - "$limit": "?number" - }, - { - "$out": { - "coll": "HASH<outColl>", - "db": "HASH<testDB>" - } - } - ] - }, - "collectionType": "collection" - })", - shapified); - - // Add the fields that shouldn't be abstracted. - acr.setAllowDiskUse(false); - acr.setHint(BSON("z" << 1 << "c" << 1)); - acr.setCollation(BSON("locale" - << "simple")); - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "collation": { - "locale": "simple" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "HASH<foo>": { - "$in": "?array<?string>" - } - }, - { - "HASH<bar>": { - "$gte": "?date" - } - } - ] - } - }, - { - "$unwind": { - "path": "$HASH<x>" - } - }, - { - "$group": { - "_id": "$HASH<_id>", - "HASH<c>": { - "$first": "$HASH<d>.HASH<e>" - }, - "HASH<f>": { - "$sum": "?number" - } - } - }, - { - "$limit": "?number" - }, - { - "$out": { - "coll": "HASH<outColl>", - "db": "HASH<testDB>" - } - } - ], - "allowDiskUse": false - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - } - })", - shapified); - - // Add let. - acr.setLet(BSON("var1" << BSON("$literal" - << "$foo") - << "var2" - << "bar")); - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "collation": { - "locale": "simple" - }, - "let": { - "HASH<var1>": "?string", - "HASH<var2>": "?string" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "HASH<foo>": { - "$in": "?array<?string>" - } - }, - { - "HASH<bar>": { - "$gte": "?date" - } - } - ] - } - }, - { - "$unwind": { - "path": "$HASH<x>" - } - }, - { - "$group": { - "_id": "$HASH<_id>", - "HASH<c>": { - "$first": "$HASH<d>.HASH<e>" - }, - "HASH<f>": { - "$sum": "?number" - } - } - }, - { - "$limit": "?number" - }, - { - "$out": { - "coll": "HASH<outColl>", - "db": "HASH<testDB>" - } - } - ], - "allowDiskUse": false - }, - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - } - })", - shapified); - - // Add the fields that should be abstracted. - auto cursorOptions = SimpleCursorOptions(); - cursorOptions.setBatchSize(10); - acr.setCursor(cursorOptions); - acr.setMaxTimeMS(500); - acr.setBypassDocumentValidation(true); - expCtx->opCtx->setComment(BSON("comment" - << "note to self")); - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "collation": { - "locale": "simple" - }, - "let": { - "HASH<var1>": "?string", - "HASH<var2>": "?string" - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "HASH<foo>": { - "$in": "?array<?string>" - } - }, - { - "HASH<bar>": { - "$gte": "?date" - } - } - ] - } - }, - { - "$unwind": { - "path": "$HASH<x>" - } - }, - { - "$group": { - "_id": "$HASH<_id>", - "HASH<c>": { - "$first": "$HASH<d>.HASH<e>" - }, - "HASH<f>": { - "$sum": "?number" - } - } - }, - { - "$limit": "?number" - }, - { - "$out": { - "coll": "HASH<outColl>", - "db": "HASH<testDB>" - } - } - ], - "allowDiskUse": false - }, - "comment": "?string", - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - }, - "maxTimeMS": "?number", - "bypassDocumentValidation": true, - "cursor": { - "batchSize": "?number" - } - })", - shapified); - - // Test again but with the representative query shape. - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToRepresentativeParseableValue, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "collation": { - "locale": "simple" - }, - "let": { - "HASH<var1>": { - "$const": "?" - }, - "HASH<var2>": { - "$const": "?" - } - }, - "command": "aggregate", - "pipeline": [ - { - "$match": { - "$and": [ - { - "HASH<foo>": { - "$in": [ - "?" - ] - } - }, - { - "HASH<bar>": { - "$gte": {"$date":"1970-01-01T00:00:00.000Z"} - } - } - ] - } - }, - { - "$unwind": { - "path": "$HASH<x>" - } - }, - { - "$group": { - "_id": "$HASH<_id>", - "HASH<c>": { - "$first": "$HASH<d>.HASH<e>" - }, - "HASH<f>": { - "$sum": { - "$const": 1 - } - } - } - }, - { - "$limit": 1 - }, - { - "$out": { - "coll": "HASH<outColl>", - "db": "HASH<testDB>" - } - } - ], - "allowDiskUse": false - }, - "comment": "?", - "collectionType": "collection", - "hint": { - "HASH<z>": 1, - "HASH<c>": 1 - }, - "maxTimeMS": 1, - "bypassDocumentValidation": true, - "cursor": { - "batchSize": 1 - } - })", - shapified); -} - -TEST_F(QueryStatsStoreTest, CorrectlyTokenizesAggregateCommandRequestEmptyFields) { - auto expCtx = make_intrusive<ExpressionContextForTest>(*kDefaultTestNss.nss()); - AggregateCommandRequest acr(*kDefaultTestNss.nss()); - acr.setPipeline({}); - auto pipeline = Pipeline::parse({}, expCtx); - - auto shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "aggregate", - "pipeline": [] - }, - "collectionType": "collection" - })", - shapified); // NOLINT (test auto-update) - - // Test again with the representative query shape. - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToRepresentativeParseableValue, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "aggregate", - "pipeline": [] - }, - "collectionType": "collection" - })", - shapified); // NOLINT (test auto-update) -} - -TEST_F(QueryStatsStoreTest, - CorrectlyTokenizesAggregateCommandRequestPipelineWithSecondaryNamespaces) { - auto expCtx = make_intrusive<ExpressionContextForTest>(*kDefaultTestNss.nss()); - auto nsToUnionWith = NamespaceString(expCtx->ns.db(), "otherColl"); - expCtx->addResolvedNamespaces({nsToUnionWith}); - - AggregateCommandRequest acr(*kDefaultTestNss.nss()); - auto unionWithStage = fromjson(R"({ - $unionWith: { - coll: "otherColl", - pipeline: [{$match: {val: "foo"}}] - } - })"); - auto sortStage = fromjson("{$sort: {age: 1}}"); - auto rawPipeline = {unionWithStage, sortStage}; - acr.setPipeline(rawPipeline); - auto pipeline = Pipeline::parse(rawPipeline, expCtx); - - auto shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToDebugTypeString, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "aggregate", - "pipeline": [ - { - "$unionWith": { - "coll": "HASH<otherColl>", - "pipeline": [ - { - "$match": { - "HASH<val>": { - "$eq": "?string" - } - } - } - ] - } - }, - { - "$sort": { - "HASH<age>": 1 - } - } - ] - }, - "collectionType": "collection", - "otherNss": [ - { - "db": "HASH<testDB>", - "coll": "HASH<otherColl>" - } - ] - })", - shapified); - - // Do the same thing with the representative query shape. - shapified = makeQueryStatsKeyAggregateRequest( - acr, *pipeline, expCtx, LiteralSerializationPolicy::kToRepresentativeParseableValue, true); - ASSERT_BSONOBJ_EQ_AUTO( // NOLINT - R"({ - "queryShape": { - "cmdNs": { - "db": "HASH<testDB>", - "coll": "HASH<testColl>" - }, - "command": "aggregate", - "pipeline": [ - { - "$unionWith": { - "coll": "HASH<otherColl>", - "pipeline": [ - { - "$match": { - "HASH<val>": { - "$eq": "?" - } - } - } - ] - } - }, - { - "$sort": { - "HASH<age>": 1 - } - } - ] - }, - "collectionType": "collection", - "otherNss": [ - { - "db": "HASH<testDB>", - "coll": "HASH<otherColl>" - } - ] - })", - shapified); -} -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/query_stats_test.cpp b/src/mongo/db/query/query_stats/query_stats_test.cpp deleted file mode 100644 index 366716afdf6..00000000000 --- a/src/mongo/db/query/query_stats/query_stats_test.cpp +++ /dev/null @@ -1,175 +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 "mongo/bson/bsonobj.h" -#include "mongo/db/collection_type.h" -#include "mongo/db/namespace_string.h" -#include "mongo/db/operation_context.h" -#include "mongo/db/pipeline/expression_context.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/parsed_find_command.h" -#include "mongo/db/query/query_stats/find_key.h" -#include "mongo/db/query/query_stats/query_stats.h" -#include "mongo/db/service_context_test_fixture.h" -#include "mongo/idl/server_parameter_test_util.h" -#include "mongo/unittest/unittest.h" -#include "mongo/util/assert_util.h" - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQueryStats - -namespace mongo::query_stats { -class QueryStatsTest : public ServiceContextTest {}; - -TEST_F(QueryStatsTest, TwoRegisterRequestsWithSameOpCtxRateLimitedFirstCall) { - // This test simulates what happens with queries over views where two calls to registerRequest() - // can be made with the same opCtx. - - // Make query for query stats. - const NamespaceString nss = NamespaceString("testDB.testColl"); - FindCommandRequest fcr((NamespaceStringOrUUID(nss))); - fcr.setFilter(BSONObj()); - - auto fcrCopy = std::make_unique<FindCommandRequest>(fcr); - auto opCtx = makeOperationContext(); - auto expCtx = make_intrusive<ExpressionContextForTest>(); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcrCopy)})); - - auto& opDebug = CurOp::get(*opCtx)->debug(); - ASSERT_EQ(opDebug.queryStatsInfo.wasRateLimited, false); - - // First call to registerRequest() should be rate limited. - QueryStatsStoreManager::getRateLimiter(opCtx->getServiceContext()) = - std::make_unique<RateLimiting>(0, Seconds{1}); - ASSERT_DOES_NOT_THROW(query_stats::registerRequest(opCtx.get(), nss, [&]() { - return std::make_unique<query_stats::FindKey>( - expCtx, *parsedFind, query_shape::CollectionType::kCollection); - })); - - // Since the query was rate limited, no key should have been created. - ASSERT(opDebug.queryStatsInfo.key == nullptr); - ASSERT_EQ(opDebug.queryStatsInfo.wasRateLimited, true); - - // Second call should not be rate limited. - QueryStatsStoreManager::getRateLimiter(opCtx->getServiceContext()) - .get() - ->setSamplingRate(INT_MAX); - - ASSERT_DOES_NOT_THROW(query_stats::registerRequest(opCtx.get(), nss, [&]() { - return std::make_unique<query_stats::FindKey>( - expCtx, *parsedFind, query_shape::CollectionType::kCollection); - })); - - // queryStatsKey should not be created for previously rate limited query. - ASSERT(opDebug.queryStatsInfo.key == nullptr); - ASSERT_EQ(opDebug.queryStatsInfo.wasRateLimited, true); - ASSERT_FALSE(opDebug.queryStatsInfo.keyHash.has_value()); -} - -TEST_F(QueryStatsTest, TwoRegisterRequestsWithSameOpCtxDisabledBetween) { - // This test simulates an observed bug where an opCtx is used for two requests, and between the - // first and the second the query stats store is emptied/disabled. - - // Make query for query stats. - const NamespaceString nss = NamespaceString("testDB.testColl"); - FindCommandRequest fcr((NamespaceStringOrUUID(nss))); - fcr.setFilter(BSONObj()); - - auto serviceCtx = getServiceContext(); - auto opCtx = makeOperationContext(); - - auto& opDebug = CurOp::get(*opCtx)->debug(); - ASSERT(opDebug.queryStatsInfo.key == nullptr); - ASSERT_FALSE(opDebug.queryStatsInfo.keyHash.has_value()); - QueryStatsStoreManager::get(serviceCtx) = - std::make_unique<QueryStatsStoreManager>(16 * 1024 * 1024, 1); - - QueryStatsStoreManager::getRateLimiter(serviceCtx) = - std::make_unique<RateLimiting>(-1, Seconds{1}); - - { - auto fcrCopy = std::make_unique<FindCommandRequest>(fcr); - auto expCtx = make_intrusive<ExpressionContext>( - opCtx.get(), *fcrCopy, nullptr, true /* mayDbProfile*/); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcrCopy)})); - ASSERT_DOES_NOT_THROW(query_stats::registerRequest(opCtx.get(), nss, [&]() { - return std::make_unique<query_stats::FindKey>( - expCtx, *parsedFind, query_shape::CollectionType::kCollection); - })); - - ASSERT(opDebug.queryStatsInfo.key != nullptr); - ASSERT(opDebug.queryStatsInfo.keyHash.has_value()); - - ASSERT_DOES_NOT_THROW(query_stats::writeQueryStats(opCtx.get(), - opDebug.queryStatsInfo.keyHash, - std::move(opDebug.queryStatsInfo.key), - 0 /*queryExecMicros*/, - 0 /*firstResponseExecMicros*/, - 0 /*docsReturned*/)); - } - - // Second call should see that query stats are now disabled. - { - // To reproduce SERVER-84730 we need to clear out the query stats store so that writing the - // stats at the end will attempt to insert a new entry. - QueryStatsStoreManager::get(serviceCtx)->resetSize(0); - - auto fcrCopy = std::make_unique<FindCommandRequest>(fcr); - fcrCopy->setFilter(BSON("x" << 1)); - auto expCtx = make_intrusive<ExpressionContext>( - opCtx.get(), *fcrCopy, nullptr, true /* mayDbProfile*/); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, {std::move(fcrCopy)})); - - ASSERT_DOES_NOT_THROW(query_stats::registerRequest(opCtx.get(), nss, [&]() { - return std::make_unique<query_stats::FindKey>( - expCtx, *parsedFind, query_shape::CollectionType::kCollection); - })); - - // queryStatsKey should not be created since we have a size budget of 0. - ASSERT(opDebug.queryStatsInfo.key == nullptr); - // This is not a rate limit, but rather a lack of space rendering it entirely disabled. - ASSERT_FALSE(opDebug.queryStatsInfo.wasRateLimited); - - // Interestingly, we purposefully leave the hash value around on the OperationContext after - // the previous operation finishes. This is because we think it may have value in being - // logged in the future, even after query stats have been written. Excepting obscure - // internal use-cases, most OperationContexts will die shortly after the query stats are - // written, so this isn't expected to be a large issue. - ASSERT(opDebug.queryStatsInfo.keyHash.has_value()); - - QueryStatsStoreManager::get(serviceCtx)->resetSize(16 * 1024 * 1024); - // SERVER-84730 this assertion used to throw since there is no key, but there is a hash. - ASSERT_DOES_NOT_THROW(query_stats::writeQueryStats(opCtx.get(), - opDebug.queryStatsInfo.keyHash, - std::move(opDebug.queryStatsInfo.key), - 0 /*queryExecMicros*/, - 0 /*firstResponseExecMicros*/, - 0 /*docsReturned*/)); - } -} -} // namespace mongo::query_stats diff --git a/src/mongo/db/query/query_stats/rate_limiting.cpp b/src/mongo/db/query/query_stats/rate_limiting.cpp deleted file mode 100644 index aa8ca645bf1..00000000000 --- a/src/mongo/db/query/query_stats/rate_limiting.cpp +++ /dev/null @@ -1,96 +0,0 @@ -/** - * Copyright (C) 2022-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 "rate_limiting.h" -#include "mongo/stdx/mutex.h" -#include "mongo/util/clock_source.h" - -namespace mongo { -RateLimiting::RateLimiting(RequestCount samplingRate, - Milliseconds timePeriod, - ClockSource* clockSource) - : _clockSource(clockSource != nullptr ? clockSource : SystemClockSource::get()), - _samplingRate(samplingRate), - _timePeriod(timePeriod), - _windowStart(_clockSource->now()), - _prevCount(0), - _currentCount(0) {} - -Date_t RateLimiting::tickWindow() { - Date_t currentTime = _clockSource->now(); - - // Elapsed time since window start exceeds the time period. Start a new window. - if (currentTime - _windowStart > _timePeriod) { - _windowStart = currentTime; - _prevCount = _currentCount; - _currentCount = 0; - } - return currentTime; -} - -bool RateLimiting::handleRequestFixedWindow() { - stdx::unique_lock windowLock{_windowMutex}; - tickWindow(); - - if (_currentCount < _samplingRate.load()) { - _currentCount += 1; - return true; - } - return false; -} - -bool RateLimiting::handleRequestSlidingWindow() { - stdx::unique_lock windowLock{_windowMutex}; - - Date_t currentTime = tickWindow(); - auto windowStart = _windowStart; - auto prevCount = _prevCount; - - // Sliding window is implemented over fixed size time periods/blocks as follows. Instead of - // making the decision to limit the rate using only the current time period, we look to the rate - // of the previous period to predicate the rate of the current. This smooths the "sampling" of - // the events by predicting a constant rate and limiting accordingly. - - // Percentage of time remaining in current window. - double percentRemainingOfCurrentWindow = - ((double)(_timePeriod.count() - (currentTime - windowStart).count())) / _timePeriod.count(); - // Estimate the number of requests remaining in the current period. We assume the requests in - // the previous time block occurred at a constant rate. We multiply the total number of requests - // in the previous period by the percentage of time remaining in the current period. - double estimatedRemaining = prevCount * percentRemainingOfCurrentWindow; - // Add this estimate to the requests we know have taken place within the current time block. - double estimatedCount = _currentCount + estimatedRemaining; - - if (estimatedCount < _samplingRate.load()) { - _currentCount += 1; - return true; - } - return false; -} -} // namespace mongo diff --git a/src/mongo/db/query/query_stats/rate_limiting.h b/src/mongo/db/query/query_stats/rate_limiting.h deleted file mode 100644 index 66e38d7119b..00000000000 --- a/src/mongo/db/query/query_stats/rate_limiting.h +++ /dev/null @@ -1,126 +0,0 @@ -/** - * Copyright (C) 2022-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. - */ - -#pragma once - -#include "mongo/util/clock_source.h" -#include "mongo/util/concurrency/mutex.h" -#include "mongo/util/system_clock_source.h" - -namespace mongo { - -/** - * Rate limiting is used to put a bound on the number of requests to a certain resource over a fixed - * time window. This implementation is approximate in the sense that it may permit the bound to - * exceeded. The bound is approximate as a trade off to reduce contention on internal resources. - */ -class RateLimiting { - using RequestCount = uint32_t; - -public: - /* - * Constructor for a rate limiter. Specify the number of requests you want to take place, as - * well as the time period in milliseconds. - */ - RateLimiting(RequestCount samplingRate, - Milliseconds timePeriod = Seconds{1}, - ClockSource* clockSource = nullptr); - - /* - * Getter for the sampling rate. - */ - RequestCount getSamplingRate() { - return _samplingRate.load(); - } - - /* - * Setter for the sampling rate. - */ - void setSamplingRate(RequestCount samplingRate) { - _samplingRate.store(samplingRate); - } - - /* - * A simple method for rate limiting. Returns false if we have reached the request limit for the - * current time window; otherwise, returns true and adds the request to the count for the - * current window. If we have passed the end of the previous window, the slate is wiped clean. - */ - bool handleRequestFixedWindow(); - - /* - * A method that ensures a more steady rate of requests. Rather than only looking at the current - * time block, this method simulates a sliding window to estimate how many requests occurred in - * the last full time period. Like the above, returns whether the request should be handled, and - * resets the window if enough time has passed. - */ - bool handleRequestSlidingWindow(); - -private: - /* - * Resets the current window if it has ended. Returns the current time. This must be called in - * the beginning of each handleRequest...() method. - */ - Date_t tickWindow(); - - /* - * Clock source used to track time. - */ - ClockSource* const _clockSource; - - /* - * Sampling rate is the bound on the number of requests we want to admit per window. - */ - AtomicWord<RequestCount> _samplingRate; - - /* - * Time period is the window size in ms. - */ - const Milliseconds _timePeriod; - - /* - * Window start. - */ - Date_t _windowStart; - - /* - * Count of requests handled in the previous window. - */ - RequestCount _prevCount; - - /* - * Count of requests handled in the current window. - */ - RequestCount _currentCount; - - /* - * Mutex used when reading/writing the window. - */ - SimpleMutex _windowMutex; -}; -} // namespace mongo diff --git a/src/mongo/db/query/query_stats/rate_limiting_bm.cpp b/src/mongo/db/query/query_stats/rate_limiting_bm.cpp deleted file mode 100644 index 06308e6b0d8..00000000000 --- a/src/mongo/db/query/query_stats/rate_limiting_bm.cpp +++ /dev/null @@ -1,144 +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 <benchmark/benchmark.h> -#include <climits> -#include <memory> - -#include "mongo/bson/json.h" -#include "mongo/db/matcher/expression_leaf.h" -#include "mongo/db/matcher/expression_parser.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_stats/rate_limiting.h" -#include "mongo/util/duration.h" -#include "mongo/util/processinfo.h" -#include "mongo/util/time_support.h" - -namespace mongo { -namespace { - -// Local testing determined that these parameter values drove the most lock contention, which is -// what we want to capture in this benchmark. -constexpr long long rateLimitedWorkTimeMicros = 5; -constexpr long long consistentWorkTimeMicros = 10; - -constexpr long long numThreads = 256; - -// Rate limit some fraction of the overall work for a request with a sliding window. -int requestWithSlidingWindow(RateLimiting& limit) { - if (limit.handleRequestSlidingWindow()) { - sleepmicros(rateLimitedWorkTimeMicros); - } - sleepmicros(consistentWorkTimeMicros); - return 0; -} - -// Represent a request that bypasses the rate limiter. -int requestUnlimited() { - constexpr long long totalTime = rateLimitedWorkTimeMicros + consistentWorkTimeMicros; - sleepmicros(totalTime); - return 0; -} - -// Represent a request without the rate limited work. -int requestDeactivated() { - sleepmicros(consistentWorkTimeMicros); - return 0; -} - -// Benchmark sliding window rate limiting. -void BM_SlidingWindow(benchmark::State& state) { - // The rate limiter needs a clock source passed in. - static std::unique_ptr<ClockSource> clockSource; - static std::unique_ptr<RateLimiting> rateLimit; - - // Initialize the rate limiter only on the first thread to start up. - if (state.thread_index == 0) { - clockSource = std::make_unique<SystemClockSource>(); - rateLimit = - std::make_unique<RateLimiting>(state.range(0), Milliseconds(1), clockSource.get()); - } - - // Run the benchmark. - for (auto keepRunning : state) { - benchmark::DoNotOptimize(requestWithSlidingWindow(*rateLimit)); - } - - // Clean up the rate limiter when the benchmark is done. - if (state.thread_index == 0) { - rateLimit.reset(); - clockSource.reset(); - } -} - -// "Control" benchmark that does not rate limit requests. In other words, the extra work is always -// done for every request. This benchmark can be thought of as the "goal" performance for the peak, -// or the highest rate limit in BM_SlidingWindow, to compare against. -void BM_Unlimited(benchmark::State& state) { - for (auto keepRunning : state) { - benchmark::DoNotOptimize(requestUnlimited()); - } -} -// Another control benchmark, where the extra work is never done for any request. This can be -// thought of as the goal performance for when rate limit equals 0. -void BM_Deactivated(benchmark::State& state) { - for (auto keepRunning : state) { - benchmark::DoNotOptimize(requestDeactivated()); - } -} - -// Google microbenchmarks report time T (in nanoseconds) spent per operation. But at Mongo we are -// interested in total opereations performed per second. The former can easily be converted to the -// latter by diving 10^6 by T. Use this benchmark to determine the natural throughput of the -// operation. This can be compared to the rate limited benchmarks (BM_SlidingWindow) to determine -// the overhead of rate limiting. Looking at the percentage change in throughput between the control -// benchmarks and the rate limited benchmark, will indicate how much overhead is due to lock -// contention. -BENCHMARK(BM_Unlimited)->Threads(numThreads); - -BENCHMARK(BM_Deactivated)->Threads(numThreads); - -// Local testing has confirmed that the higher the rate limit, the worse the throughput. This makes -// sense as putting a higher upper bound on number of requests allowed in a given time period, means -// longer wait times for the lock. -BENCHMARK(BM_SlidingWindow) - ->ArgName("rate limit") - ->Arg(0) - ->Arg(64) - ->Arg(128) - ->Arg(256) - ->Arg(512) - ->Arg(1024) - ->Arg(2048) - ->Arg(4816) - ->Threads(numThreads); - -} // namespace -} // namespace mongo diff --git a/src/mongo/db/query/query_stats/rate_limiting_test.cpp b/src/mongo/db/query/query_stats/rate_limiting_test.cpp deleted file mode 100644 index 380636a2a20..00000000000 --- a/src/mongo/db/query/query_stats/rate_limiting_test.cpp +++ /dev/null @@ -1,77 +0,0 @@ -/** - * Copyright (C) 2022-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 "mongo/db/query/query_stats/rate_limiting.h" -#include "mongo/unittest/unittest.h" -#include "mongo/util/time_support.h" - -namespace mongo { -TEST(RateLimitingTest, FixedWindowSucceeds) { - auto rl = RateLimiting(1); - ASSERT_TRUE(rl.handleRequestFixedWindow()); -} - -TEST(RateLimitingTest, SlidingWindowSucceeds) { - auto rl = RateLimiting(1); - ASSERT_TRUE(rl.handleRequestSlidingWindow()); -} - -TEST(RateLimitingTest, FixedWindowFails) { - auto rl = RateLimiting(0); - ASSERT_FALSE(rl.handleRequestFixedWindow()); -} - -TEST(RateLimitingTest, SlidingWindowFails) { - auto rl = RateLimiting(0); - ASSERT_FALSE(rl.handleRequestSlidingWindow()); -} - -TEST(RateLimitingTest, FixedWindowSucceedsThenFails) { - auto rl = RateLimiting(1, Hours{1}); - ASSERT_TRUE(rl.handleRequestFixedWindow()); - ASSERT_FALSE(rl.handleRequestFixedWindow()); - ASSERT_FALSE(rl.handleRequestFixedWindow()); -} - -TEST(RateLimitingTest, SlidingWindowSucceedsThenFails) { - auto rl = RateLimiting(1, Hours{1}); - ASSERT_TRUE(rl.handleRequestSlidingWindow()); - ASSERT_FALSE(rl.handleRequestSlidingWindow()); - ASSERT_FALSE(rl.handleRequestSlidingWindow()); -} - -TEST(RateLimitingTest, FixedWindowPermitsRequestAfterWindowExpires) { - auto rl = RateLimiting(1, Milliseconds{10}); - ASSERT_TRUE(rl.handleRequestFixedWindow()); - ASSERT_FALSE(rl.handleRequestFixedWindow()); - sleepmillis(11); - ASSERT_TRUE(rl.handleRequestFixedWindow()); -} - -} // namespace mongo diff --git a/src/mongo/db/query/query_stats/shapifying_bm.cpp b/src/mongo/db/query/query_stats/shapifying_bm.cpp deleted file mode 100644 index fd7f605c855..00000000000 --- a/src/mongo/db/query/query_stats/shapifying_bm.cpp +++ /dev/null @@ -1,142 +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 <benchmark/benchmark.h> -#include <climits> -#include <memory> - -#include "mongo/bson/json.h" -#include "mongo/db/concurrency/locker_noop_client_observer.h" -#include "mongo/db/matcher/expression_leaf.h" -#include "mongo/db/matcher/expression_parser.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/query_shape/query_shape.h" -#include "mongo/db/query/query_stats/find_key.h" -#include "mongo/db/query/query_stats/query_stats.h" -#include "mongo/db/query/query_stats/rate_limiting.h" -#include "mongo/idl/server_parameter_test_util.h" -#include "mongo/rpc/metadata/client_metadata.h" -#include "mongo/util/duration.h" -#include "mongo/util/processinfo.h" -#include "mongo/util/testing_proctor.h" -#include "mongo/util/time_support.h" - -namespace mongo { -namespace { - -static const NamespaceStringOrUUID kDefaultTestNss = - NamespaceStringOrUUID{NamespaceString("testDB.testColl")}; - -static constexpr auto kCollectionType = query_shape::CollectionType::kCollection; - -// This is a snapshot of the client metadata generated from our IDHACK genny workload. The -// specifics aren't so important, but it chosen in an attempt to be indicative of the size/shape -// of this kind of thing "in the wild". -const auto kMetadataWrapper = fromjson(R"({metadata: { - "application" : { - "name" : "Genny" - }, - "driver" : { - "name" : "mongoc / mongocxx", - "version" : "1.23.2 / 3.7.0" - }, - "os" : { - "type" : "Linux", - "name" : "Ubuntu", - "version" : "22.04", - "architecture" : "aarch64" - }, - "platform" : "cfg=0x03215e88e9 posix=200809 stdc=201710 CC=GCC 11.3.0 CFLAGS=\"-fPIC\" LDFLAGS=\"\"" - }})"); -auto kMockClientMetadataElem = kMetadataWrapper["metadata"]; - -auto makeFindKey(const boost::intrusive_ptr<ExpressionContext>& expCtx, - const ParsedFindCommand& parsedFind) { - return std::make_unique<const query_stats::FindKey>(expCtx, parsedFind, kCollectionType); -} - -int shapifyAndHashRequest(const boost::intrusive_ptr<ExpressionContext>& expCtx, - const ParsedFindCommand& parsedFind) { - auto key = makeFindKey(expCtx, parsedFind); - [[maybe_unused]] auto hash = absl::Hash<query_stats::Key>{}(*key); - return 0; -} - -// Benchmark the performance of computing and hashing the query stats key for an IDHACK query. -void BM_ShapfiyIDHack(benchmark::State& state) { - auto serviceCtx = ServiceContext::make(); - serviceCtx->registerClientObserver(std::make_unique<LockerNoopClientObserver>()); - - auto client = serviceCtx->makeClient("query_test"); - - auto opCtx = client->makeOperationContext(); - auto expCtx = make_intrusive<ExpressionContextForTest>(opCtx.get()); - auto fcr = std::make_unique<FindCommandRequest>(expCtx->ns); - fcr->setFilter(fromjson("{_id: 4}")); - ClientMetadata::setFromMetadata(opCtx->getClient(), kMockClientMetadataElem); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, std::move(fcr))); - - // Run the benchmark. - for (auto keepRunning : state) { - benchmark::DoNotOptimize(shapifyAndHashRequest(expCtx, *parsedFind)); - } -} - -// Benchmark computing the query stats key and its hash for a mildly complex query predicate. -void BM_ShapfiyMildlyComplex(benchmark::State& state) { - auto serviceCtx = ServiceContext::make(); - serviceCtx->registerClientObserver(std::make_unique<LockerNoopClientObserver>()); - - auto client = serviceCtx->makeClient("query_test"); - - auto opCtx = client->makeOperationContext(); - auto expCtx = make_intrusive<ExpressionContextForTest>(opCtx.get()); - auto fcr = std::make_unique<FindCommandRequest>(expCtx->ns); - fcr->setFilter(fromjson(R"({ - clientId: {$nin: ["432345", "4386945", "111111"]}, - nEmployees: {$gte: 4, $lt: 20}, - deactivated: false, - region: "US", - yearlySpend: {$lte: 1000} - })")); - ClientMetadata::setFromMetadata(opCtx->getClient(), kMockClientMetadataElem); - auto parsedFind = uassertStatusOK(parsed_find_command::parse(expCtx, std::move(fcr))); - - // Run the benchmark. - for (auto keepRunning : state) { - benchmark::DoNotOptimize(shapifyAndHashRequest(expCtx, *parsedFind)); - } -} - -BENCHMARK(BM_ShapfiyIDHack)->Threads(1); -BENCHMARK(BM_ShapfiyMildlyComplex)->Threads(1); - -} // namespace -} // namespace mongo diff --git a/src/mongo/db/query/query_stats/transform_algorithm.idl b/src/mongo/db/query/query_stats/transform_algorithm.idl deleted file mode 100644 index cd0a5ba43db..00000000000 --- a/src/mongo/db/query/query_stats/transform_algorithm.idl +++ /dev/null @@ -1,37 +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. -# -global: - cpp_namespace: "mongo" - -enums: - TransformAlgorithm: - description: "The type of algorithm to be used for the transformIdentifiers field of $queryStats." - type: string - values: - kHmacSha256: "hmac-sha-256" - kNone: "none" diff --git a/src/mongo/db/query/record_id_bound.h b/src/mongo/db/query/record_id_bound.h index d6a37617a4f..99400ae938d 100644 --- a/src/mongo/db/query/record_id_bound.h +++ b/src/mongo/db/query/record_id_bound.h @@ -29,7 +29,6 @@ #pragma once -#include <boost/operators.hpp> #include <boost/optional.hpp> #include <fmt/format.h> #include <ostream> @@ -45,7 +44,7 @@ namespace mongo { /** * A RecordId bound for a collection scan, with an optional BSON representation for pretty printing. */ -class RecordIdBound : boost::totally_ordered<RecordIdBound> { +class RecordIdBound { public: RecordIdBound() = default; @@ -82,14 +81,6 @@ public: return _recordId.compare(rhs._recordId); } - bool operator==(const RecordIdBound& rhs) const { - return compare(rhs) == 0; - } - - bool operator<(const RecordIdBound& rhs) const { - return compare(rhs) < 0; - } - private: RecordId _recordId; boost::optional<BSONObj> _bson; diff --git a/src/mongo/db/query/record_id_range.cpp b/src/mongo/db/query/record_id_range.cpp deleted file mode 100644 index 88720183ef4..00000000000 --- a/src/mongo/db/query/record_id_range.cpp +++ /dev/null @@ -1,109 +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 <boost/optional.hpp> - -#include "mongo/db/query/record_id_range.h" - -namespace mongo { -void RecordIdRange::maybeNarrowMin(const BSONObj& newMin, bool inclusive) { - maybeNarrowMin(RecordIdBound(record_id_helpers::keyForObj(newMin), newMin), inclusive); -} - -void RecordIdRange::maybeNarrowMin(const RecordIdBound& newMin, bool inclusive) { - if (_min) { - auto cmp = _min->compare(newMin); - // The range only needs updating if: - // * There's no existing _min - // * The provided value is greater than the current _min - // * The value == _min, but is _not_ inclusive, but the existing value is - - if (cmp > 0) { - // Current min is strictly greater than the provided value (and existing value has been - // initialised), nothing to do. - return; - } - - if (cmp == 0) { - // Inclusivity moving true -> false narrows the range. - _minInclusive = _minInclusive && inclusive; - return; - } - } - _min = newMin; - // The bound value changed, so the previous value of _minInclusive is irrelevant. - _minInclusive = inclusive; -} - -void RecordIdRange::maybeNarrowMax(const BSONObj& newMax, bool inclusive) { - maybeNarrowMax(RecordIdBound(record_id_helpers::keyForObj(newMax), newMax), inclusive); -} - -void RecordIdRange::maybeNarrowMax(const RecordIdBound& newMax, bool inclusive) { - if (_max) { - auto cmp = _max->compare(newMax); - // The range only needs updating if: - // * There's no existing _max - // * The provided value is less than the current _max - // * The value == _max, but is _not_ inclusive, but the existing value is - - if (cmp < 0) { - // Current max is strictly less than the provided value (and existing value has been - // initialised), nothing to do. - return; - } - - if (cmp == 0) { - // Inclusivity moving true -> false narrows the range. - _maxInclusive = _maxInclusive && inclusive; - return; - } - } - _max = newMax; - // The bound value changed, so the previous value of _maxInclusive is irrelevant. - _maxInclusive = inclusive; -} - -void RecordIdRange::intersectRange(const RecordIdRange& other) { - intersectRange(other._min, other._max, other._minInclusive, other._maxInclusive); -} - -void RecordIdRange::intersectRange(const boost::optional<RecordIdBound>& min, - const boost::optional<RecordIdBound>& max, - bool minInclusive, - bool maxInclusive) { - if (min) { - maybeNarrowMin(*min, minInclusive); - } - if (max) { - maybeNarrowMax(*max, maxInclusive); - } -} - -} // namespace mongo diff --git a/src/mongo/db/query/record_id_range.h b/src/mongo/db/query/record_id_range.h deleted file mode 100644 index d25e17356c1..00000000000 --- a/src/mongo/db/query/record_id_range.h +++ /dev/null @@ -1,117 +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. - */ - -#pragma once - - -#include <boost/optional.hpp> - -#include "mongo/bson/bsonobj.h" -#include "mongo/db/query/record_id_bound.h" - -namespace mongo { - -class RecordIdRange { -public: - /** - * If the provided value @p newMin is greater than the existing min, - * update the lower bound to equal @p newMin - * - * @return true if range was adjusted - */ - void maybeNarrowMin(const BSONObj& newMin, bool inclusive); - void maybeNarrowMin(const RecordIdBound& newMin, bool inclusive); - - /** - * If the provided value @p newMax is less than the existing max, - * update the upper bound to equal @p newMax - * - * @return true if range was adjusted - */ - void maybeNarrowMax(const BSONObj& newMax, bool inclusive); - void maybeNarrowMax(const RecordIdBound& newMax, bool inclusive); - - /** - * Update this range to the intersection of this range - * and @p other. This may update both, one of, or neither of - * min and max. - * - * Results in a range which is either unchanged, or made - * narrower (possibly becoming an empty range). - */ - void intersectRange(const RecordIdRange& other); - /** - * Overload of intersectRange taking the components of a RecordIdRange, - * for convenience when the other range is not handled as a RecordIdRange. - */ - void intersectRange(const boost::optional<RecordIdBound>& min, - const boost::optional<RecordIdBound>& max, - bool minInclusive = true, - bool maxInclusive = true); - - bool isEmpty() const; - - - const auto& getMin() const { - return _min; - } - - const auto& getMax() const { - return _max; - } - - bool isMinInclusive() const { - return _minInclusive; - } - - bool isMaxInclusive() const { - return _maxInclusive; - } - - -private: - // If present, this parameter sets the start point of a forward scan or the end point of a - // reverse scan. - boost::optional<RecordIdBound> _min; - - // If present, this parameter sets the start point of a reverse scan or the end point of a - // forward scan. - boost::optional<RecordIdBound> _max; - - // TODO: investigate folding this into RecordIdBound; many other usages pair RecordIdBound - // with ScanBoundInclusion to convey this information - // If min is present, this indicates whether the range is inclusive or exclusive of the - // set min value - bool _minInclusive = true; - // If max is present, this indicates whether the range is inclusive or exclusive of the - // set max value - bool _maxInclusive = true; -}; - -} // namespace mongo diff --git a/src/mongo/db/query/record_id_range_test.cpp b/src/mongo/db/query/record_id_range_test.cpp deleted file mode 100644 index 5db866a73d3..00000000000 --- a/src/mongo/db/query/record_id_range_test.cpp +++ /dev/null @@ -1,119 +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 "mongo/base/error_extra_info.h" -#include "mongo/bson/bsonmisc.h" -#include "mongo/db/query/record_id_range.h" - -#include "mongo/bson/bsonmisc.h" -#include "mongo/unittest/unittest.h" - -namespace { - -using namespace mongo; - -template <class BoundsCheck, class NarrowingCheck, class InclusivityCheck> -void testRange(const BoundsCheck& getBoundOptional, - const NarrowingCheck& maybeNarrowBound, - const InclusivityCheck& checkInclusivity, - int initialValue, - int narrowerValue, - int widerValue) { - ASSERT_FALSE(getBoundOptional()); - - auto assertValueEq = [&](auto value) { - auto bson = BSON("value" << value); - auto recordId = record_id_helpers::keyForObj(bson); - ASSERT_EQ(recordId, getBoundOptional()->recordId()); - }; - - // narrow from unset - maybeNarrowBound(BSON("value" << initialValue), true /* inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(initialValue); - ASSERT_TRUE(checkInclusivity()); - - // narrow by removing inclusivity of the bound - maybeNarrowBound(BSON("value" << initialValue), false /* not inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(initialValue); - ASSERT_FALSE(checkInclusivity()); - - // cannot widen by re-adding inclusivity - maybeNarrowBound(BSON("value" << initialValue), true /* inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(initialValue); - ASSERT_FALSE(checkInclusivity()); - - // cannot widen by setting a wider bound - maybeNarrowBound(BSON("value" << widerValue), true /* inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(initialValue); - ASSERT_FALSE(checkInclusivity()); - - // cannot widen by setting a wider bound, regardless of inclusivity - maybeNarrowBound(BSON("value" << widerValue), false /* not inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(initialValue); - ASSERT_FALSE(checkInclusivity()); - - // narrow to a non-inclusive bound at a narrower value - maybeNarrowBound(BSON("value" << narrowerValue), false /* not inclusive */); - ASSERT_TRUE(getBoundOptional()); - assertValueEq(narrowerValue); - ASSERT_FALSE(checkInclusivity()); -} - -TEST(RecordIdRangeTest, NarrowMin) { - RecordIdRange range; - - testRange([&] { return range.getMin(); }, - [&](const BSONObj& newVal, bool inclusive) { - return range.maybeNarrowMin(newVal, inclusive); - }, - [&] { return range.isMinInclusive(); }, - 10, - 11, - 9); -} - -TEST(RecordIdRangeTest, NarrowMax) { - RecordIdRange range; - - testRange([&] { return range.getMax(); }, - [&](const BSONObj& newVal, bool inclusive) { - return range.maybeNarrowMax(newVal, inclusive); - }, - [&] { return range.isMaxInclusive(); }, - 10, - 9, - 11); -} - -} // namespace diff --git a/src/mongo/db/query/sbe_cached_solution_planner.cpp b/src/mongo/db/query/sbe_cached_solution_planner.cpp index cd7f23016eb..c594c70f22e 100644 --- a/src/mongo/db/query/sbe_cached_solution_planner.cpp +++ b/src/mongo/db/query/sbe_cached_solution_planner.cpp @@ -74,7 +74,6 @@ CandidatePlans CachedSolutionPlanner::plan( std::move(roots[0].first), std::move(roots[0].second), maxReadsBeforeReplan); - auto explainer = plan_explainer_factory::make( candidate.root.get(), &candidate.data, diff --git a/src/mongo/db/query/sbe_multi_planner.cpp b/src/mongo/db/query/sbe_multi_planner.cpp index a0d6e975694..5f2104a0668 100644 --- a/src/mongo/db/query/sbe_multi_planner.cpp +++ b/src/mongo/db/query/sbe_multi_planner.cpp @@ -32,6 +32,7 @@ #include "mongo/db/query/sbe_multi_planner.h" +#include "mongo/db/exec/multi_plan.h" #include "mongo/db/exec/sbe/expressions/expression.h" #include "mongo/db/exec/sbe/values/bson.h" #include "mongo/db/query/collection_query_info.h" diff --git a/src/mongo/db/query/sbe_plan_cache.cpp b/src/mongo/db/query/sbe_plan_cache.cpp index 70d864e7074..b699387cc47 100644 --- a/src/mongo/db/query/sbe_plan_cache.cpp +++ b/src/mongo/db/query/sbe_plan_cache.cpp @@ -31,7 +31,7 @@ #include "mongo/db/query/sbe_plan_cache.h" -#include "mongo/db/query/util/memory_util.h" +#include "mongo/db/query/plan_cache_size_parameter.h" #include "mongo/db/server_options.h" #include "mongo/logv2/log.h" #include "mongo/util/processinfo.h" @@ -42,23 +42,71 @@ namespace { const auto sbePlanCacheDecoration = ServiceContext::declareDecoration<std::unique_ptr<sbe::PlanCache>>(); +size_t convertToSizeInBytes(const plan_cache_util::PlanCacheSizeParameter& param) { + constexpr size_t kBytesInMB = 1014 * 1024; + constexpr size_t kMBytesInGB = 1014; + + double sizeInMB = param.size; + + switch (param.units) { + case plan_cache_util::PlanCacheSizeUnits::kPercent: + sizeInMB *= ProcessInfo::getMemSizeMB() / 100.0; + break; + case plan_cache_util::PlanCacheSizeUnits::kMB: + break; + case plan_cache_util::PlanCacheSizeUnits::kGB: + sizeInMB *= kMBytesInGB; + break; + } + + return static_cast<size_t>(sizeInMB * kBytesInMB); +} + +/** + * Sets upper size limit on the PlanCache size to 500GB or 25% of the system's memory, whichever is + * smaller. + */ +size_t capPlanCacheSize(size_t planCacheSize) { + constexpr size_t kBytesInGB = 1024 * 1024 * 1024; + + // Maximum size of the plan cache expressed in bytes. + constexpr size_t kMaximumPlanCacheSize = 500 * kBytesInGB; + + // Maximum size of the plan cache expressed as a share of the memory available to the process. + const plan_cache_util::PlanCacheSizeParameter limitToProcessSize{ + 25, plan_cache_util::PlanCacheSizeUnits::kPercent}; + const size_t limitToProcessSizeInBytes = convertToSizeInBytes(limitToProcessSize); + + // The size will be capped by the minimum of the two values defined above. + const size_t maxPlanCacheSize = std::min(kMaximumPlanCacheSize, limitToProcessSizeInBytes); + + if (planCacheSize > maxPlanCacheSize) { + planCacheSize = maxPlanCacheSize; + LOGV2_DEBUG(6007000, + 1, + "The plan cache size has been capped", + "maxPlanCacheSize"_attr = maxPlanCacheSize); + } + + return planCacheSize; +} + +size_t getPlanCacheSizeInBytes(const plan_cache_util::PlanCacheSizeParameter& param) { + size_t planCacheSize = convertToSizeInBytes(param); + uassert(5968001, + "Cache size must be at least 1KB * number of cores", + planCacheSize >= 1024 * ProcessInfo::getNumCores()); + return capPlanCacheSize(planCacheSize); +} class PlanCacheOnParamChangeUpdaterImpl final : public plan_cache_util::OnParamChangeUpdater { public: - void updateCacheSize(ServiceContext* serviceCtx, memory_util::MemorySize memSize) final { + void updateCacheSize(ServiceContext* serviceCtx, + plan_cache_util::PlanCacheSizeParameter parameter) final { if (feature_flags::gFeatureFlagSbePlanCache.isEnabledAndIgnoreFCV()) { - auto newSizeBytes = memory_util::getRequestedMemSizeInBytes(memSize); - auto cappedCacheSize = memory_util::capMemorySize(newSizeBytes /*requestedSizeBytes*/, - 500 /*maximumSizeGB*/, - 25 /*percentTotalSystemMemory*/); - if (cappedCacheSize < newSizeBytes) { - LOGV2_DEBUG(6007001, - 1, - "The plan cache size has been capped", - "cappedSize"_attr = cappedCacheSize); - } + auto size = getPlanCacheSizeInBytes(parameter); auto& globalPlanCache = sbePlanCacheDecoration(serviceCtx); - globalPlanCache->reset(cappedCacheSize); + globalPlanCache->reset(size); } } @@ -76,21 +124,12 @@ ServiceContext::ConstructorActionRegisterer planCacheRegisterer{ std::make_unique<PlanCacheOnParamChangeUpdaterImpl>(); if (feature_flags::gFeatureFlagSbePlanCache.isEnabledAndIgnoreFCV()) { - auto status = memory_util::MemorySize::parse(planCacheSize.get()); + auto status = plan_cache_util::PlanCacheSizeParameter::parse(planCacheSize.get()); uassertStatusOK(status); - auto size = memory_util::getRequestedMemSizeInBytes(status.getValue()); - auto cappedCacheSize = memory_util::capMemorySize(size /*requestedSizeBytes*/, - 500 /*maximumSizeGB*/, - 25 /*percentTotalSystemMemory*/); - if (cappedCacheSize < size) { - LOGV2_DEBUG(6007000, - 1, - "The plan cache size has been capped", - "cappedSize"_attr = cappedCacheSize); - } + + auto size = getPlanCacheSizeInBytes(status.getValue()); auto& globalPlanCache = sbePlanCacheDecoration(serviceCtx); - globalPlanCache = - std::make_unique<sbe::PlanCache>(cappedCacheSize, ProcessInfo::getNumCores()); + globalPlanCache = std::make_unique<sbe::PlanCache>(size, ProcessInfo::getNumCores()); } }}; diff --git a/src/mongo/db/query/sbe_plan_cache.h b/src/mongo/db/query/sbe_plan_cache.h index 090df251bdf..6e7853fa817 100644 --- a/src/mongo/db/query/sbe_plan_cache.h +++ b/src/mongo/db/query/sbe_plan_cache.h @@ -190,14 +190,7 @@ struct CachedSbePlan { using PlanCacheEntry = PlanCacheEntryBase<CachedSbePlan, plan_cache_debug_info::DebugInfoSBE>; struct BudgetEstimator { - /** - * This estimator function is called when an entry is added or removed to LRU cache in order to - * make sure the total plan cache size does not exceed the maximum size. - */ - size_t operator()(const sbe::PlanCacheKey& key, - const std::shared_ptr<const PlanCacheEntry>& entry) { - // TODO: SERVER-73649 include size of underlying query shape and size of int_32 key hash in - // total size estimation. + size_t operator()(const std::shared_ptr<const PlanCacheEntry>& entry) { return entry->estimatedEntrySizeBytes; } }; diff --git a/src/mongo/db/query/sbe_plan_cache_on_parameter_change.cpp b/src/mongo/db/query/sbe_plan_cache_on_parameter_change.cpp index 9f6cbef6d4f..399d5210128 100644 --- a/src/mongo/db/query/sbe_plan_cache_on_parameter_change.cpp +++ b/src/mongo/db/query/sbe_plan_cache_on_parameter_change.cpp @@ -56,7 +56,7 @@ Status clearSbeCacheOnParameterChangeHelper() { } Status onPlanCacheSizeUpdate(const std::string& str) { - auto newSize = memory_util::MemorySize::parse(str); + auto newSize = PlanCacheSizeParameter::parse(str); if (!newSize.isOK()) { return newSize.getStatus(); } @@ -73,7 +73,7 @@ Status onPlanCacheSizeUpdate(const std::string& str) { } Status validatePlanCacheSize(const std::string& str) { - uasserted(7529500, "planCacheSize is not a supported parameter in 6.0"); + return PlanCacheSizeParameter::parse(str).getStatus(); } const Decorable<ServiceContext>::Decoration<std::unique_ptr<OnParamChangeUpdater>> diff --git a/src/mongo/db/query/sbe_plan_cache_on_parameter_change.h b/src/mongo/db/query/sbe_plan_cache_on_parameter_change.h index d0f8a026a05..e126dda9f48 100644 --- a/src/mongo/db/query/sbe_plan_cache_on_parameter_change.h +++ b/src/mongo/db/query/sbe_plan_cache_on_parameter_change.h @@ -32,7 +32,7 @@ #include <string> #include "mongo/base/status.h" -#include "mongo/db/query/util/memory_util.h" +#include "mongo/db/query/plan_cache_size_parameter.h" #include "mongo/db/service_context.h" namespace mongo::plan_cache_util { @@ -70,11 +70,11 @@ public: virtual ~OnParamChangeUpdater() = default; /** - * Resizes the SBE plan cache decorating 'serviceCtx' to the new size given by 'memSize'. If + * Resizes the SBE plan cache decorating 'serviceCtx' to the new size given by 'parameter'. If * the new cache size is smaller than the old, cache entries are evicted in order to ensure the * cache fits within the new size bound. */ - virtual void updateCacheSize(ServiceContext* serviceCtx, memory_util::MemorySize memSize) = 0; + virtual void updateCacheSize(ServiceContext* serviceCtx, PlanCacheSizeParameter parameter) = 0; /** * Deletes all plans from the SBE plan cache decorating 'serviceCtx'. diff --git a/src/mongo/db/query/sbe_stage_builder.cpp b/src/mongo/db/query/sbe_stage_builder.cpp index 7a2b2a9bdef..d35fcc774b0 100644 --- a/src/mongo/db/query/sbe_stage_builder.cpp +++ b/src/mongo/db/query/sbe_stage_builder.cpp @@ -769,9 +769,12 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder } // If the slots necessary for performing an index consistency check were not requested in - // 'reqs', then set 'doIndexConsistencyCheck' to false to avoid generating unnecessary logic. - bool doIndexConsistencyCheck = - reqs.has(kSnapshotId) && reqs.has(kIndexId) && reqs.has(kIndexKey); + // 'reqs', then don't pass a pointer to 'iamMap' so 'generateIndexScan' doesn't generate the + // necessary slots. + auto iamMap = &_data.iamMap; + if (!(reqs.has(kSnapshotId) && reqs.has(kIndexId) && reqs.has(kIndexKey))) { + iamMap = nullptr; + } const auto generateIndexScanFunc = ixn->iets.empty() ? generateIndexScan : generateIndexScanWithDynamicBounds; @@ -780,7 +783,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder ixn, indexKeyBitset, _yieldPolicy, - doIndexConsistencyCheck, + iamMap, reqs.has(kIndexKeyPattern)); if (reqs.has(PlanStageSlots::kReturnKey)) { @@ -922,6 +925,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder auto [stage, outputs] = build(fn->children[0], childReqs); + auto iamMap = _data.iamMap; uassert(4822880, "RecordId slot is not defined", outputs.has(kRecordId)); uassert( 4953600, "ReturnKey slot is not defined", !reqs.has(kReturnKey) || outputs.has(kReturnKey)); @@ -949,6 +953,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder outputs.get(kIndexKey), outputs.get(kIndexKeyPattern), getCurrentCollection(reqs), + std::move(iamMap), root->nodeId(), std::move(relevantSlots), _slotIdGenerator); @@ -1997,17 +2002,27 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder auto outerChild = andSortedNode->children[0]; auto innerChild = andSortedNode->children[1]; - auto outerChildReqs = childReqs.copy() - .clear(kSnapshotId) - .clear(kIndexId) - .clear(kIndexKey) - .clear(kIndexKeyPattern); - auto [outerStage, outerOutputs] = build(outerChild, outerChildReqs); + auto [outerStage, outerOutputs] = build(outerChild, childReqs); auto outerIdSlot = outerOutputs.get(kRecordId); auto outerResultSlot = outerOutputs.get(kResult); auto outerKeySlots = sbe::makeSV(outerIdSlot); auto outerProjectSlots = sbe::makeSV(outerResultSlot); + if (outerOutputs.has(kSnapshotId)) { + outerProjectSlots.push_back(outerOutputs.get(kSnapshotId)); + } + + if (outerOutputs.has(kIndexId)) { + outerProjectSlots.push_back(outerOutputs.get(kIndexId)); + } + + if (outerOutputs.has(kIndexKey)) { + outerProjectSlots.push_back(outerOutputs.get(kIndexKey)); + } + + if (outerOutputs.has(kIndexKeyPattern)) { + outerProjectSlots.push_back(outerOutputs.get(kIndexKeyPattern)); + } auto [innerStage, innerOutputs] = build(innerChild, childReqs); tassert(5073707, "innerOutputs must contain kRecordId slot", innerOutputs.has(kRecordId)); @@ -2085,104 +2100,44 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder namespace { template <typename F> -struct FieldPathAndCondPreVisitor : public SelectiveConstExpressionVisitorBase { +struct FieldPathVisitor : public SelectiveConstExpressionVisitorBase { // To avoid overloaded-virtual warnings. using SelectiveConstExpressionVisitorBase::visit; - FieldPathAndCondPreVisitor(const F& fn, int32_t& nestedCondLevel) - : _fn(fn), _nestedCondLevel(nestedCondLevel) {} + FieldPathVisitor(const F& fn) : _fn(fn) {} void visit(const ExpressionFieldPath* expr) final { - _fn(expr, _nestedCondLevel); - } - - void visit(const ExpressionCond* expr) final { - ++_nestedCondLevel; - } - - void visit(const ExpressionSwitch* expr) final { - ++_nestedCondLevel; - } - - void visit(const ExpressionIfNull* expr) final { - ++_nestedCondLevel; - } - - void visit(const ExpressionAnd* expr) final { - ++_nestedCondLevel; - } - - void visit(const ExpressionOr* expr) final { - ++_nestedCondLevel; + _fn(expr); } F _fn; - // Tracks the number of conditional expressions like $cond or $ifNull that are above us in the - // tree. - int32_t& _nestedCondLevel; -}; - -struct CondPostVisitor : public SelectiveConstExpressionVisitorBase { - // To avoid overloaded-virtual warnings. - using SelectiveConstExpressionVisitorBase::visit; - - CondPostVisitor(int32_t& nestedCondLevel) : _nestedCondLevel(nestedCondLevel) {} - - void visit(const ExpressionCond* expr) final { - --_nestedCondLevel; - } - - void visit(const ExpressionSwitch* expr) final { - --_nestedCondLevel; - } - - void visit(const ExpressionIfNull* expr) final { - --_nestedCondLevel; - } - - void visit(const ExpressionAnd* expr) final { - --_nestedCondLevel; - } - - void visit(const ExpressionOr* expr) final { - --_nestedCondLevel; - } - - int32_t& _nestedCondLevel; }; /** * Walks through the 'expr' expression tree and whenever finds an 'ExpressionFieldPath', calls * the 'fn' function. Type requirement for 'fn' is it must have a const 'ExpressionFieldPath' - * pointer parameter and 'nestedCondLevel' parameter. + * pointer parameter. */ template <typename F> void walkAndActOnFieldPaths(Expression* expr, const F& fn) { - int32_t nestedCondLevel = 0; - FieldPathAndCondPreVisitor<F> preVisitor(fn, nestedCondLevel); - CondPostVisitor postVisitor(nestedCondLevel); - ExpressionWalker walker(&preVisitor, nullptr /*inVisitor*/, &postVisitor); + FieldPathVisitor<F> visitor(fn); + ExpressionWalker walker(&visitor, nullptr /*inVisitor*/, nullptr /*postVisitor*/); expression_walker::walk(expr, &walker); } /** * Checks whether all field paths in 'idExpr' and all accumulator expressions are top-level ones. */ -bool areAllFieldPathsOptimizable(const boost::intrusive_ptr<Expression>& idExpr, - const std::vector<AccumulationStatement>& accStmts) { - auto areFieldPathsOptimizable = true; +bool checkAllFieldPathsAreTopLevel(const boost::intrusive_ptr<Expression>& idExpr, + const std::vector<AccumulationStatement>& accStmts) { + auto areAllTopLevelFields = true; - auto checkFieldPath = [&](const ExpressionFieldPath* fieldExpr, int32_t nestedCondLevel) { + auto checkFieldPath = [&](const ExpressionFieldPath* fieldExpr) { // We optimize neither a field path for the top-level document itself (getPathLength() == 1) // nor a field path that refers to a variable. We can optimize only top-level fields // (getPathLength() == 2). - // - // The 'nestedCondLevel' being > 0 means that a field path is refered to below conditional - // expressions at the parent $group node, when we cannot optimize field path access and - // therefore, cannot avoid materialization. - if (nestedCondLevel > 0 || fieldExpr->getFieldPath().getPathLength() != 2 || - fieldExpr->isVariableReference()) { - areFieldPathsOptimizable = false; + if (fieldExpr->getFieldPath().getPathLength() != 2 || fieldExpr->isVariableReference()) { + areAllTopLevelFields = false; return; } }; @@ -2195,7 +2150,7 @@ bool areAllFieldPathsOptimizable(const boost::intrusive_ptr<Expression>& idExpr, walkAndActOnFieldPaths(accStmt.expr.argument.get(), checkFieldPath); } - return areFieldPathsOptimizable; + return areAllTopLevelFields; } /** @@ -2221,7 +2176,7 @@ EvalStage optimizeFieldPaths(StageBuilderState& state, auto searchInChildOutputs = !optionalRootSlot.has_value(); auto retEvalStage = std::move(childEvalStage); - walkAndActOnFieldPaths(expr.get(), [&](const ExpressionFieldPath* fieldExpr, int32_t) { + walkAndActOnFieldPaths(expr.get(), [&](const ExpressionFieldPath* fieldExpr) { // We optimize neither a field path for the top-level document itself nor a field path that // refers to a variable instead of calling getField(). if (fieldExpr->getFieldPath().getPathLength() == 1 || fieldExpr->isVariableReference()) { @@ -2352,12 +2307,20 @@ std::tuple<sbe::value::SlotVector, EvalStage, std::unique_ptr<sbe::EExpression>> nodeId, slotIdGenerator); - // The group-by field may end up being 'Nothing' and in that case _id: null will be - // returned. Calling 'makeFillEmptyNull' for the group-by field takes care of that. - auto fillEmptyNullExpr = makeFillEmptyNull(groupByEvalExpr.extractExpr()); sbe::value::SlotId slot; - std::tie(slot, retEvalStage) = projectEvalExpr( - std::move(fillEmptyNullExpr), std::move(groupByEvalStage), nodeId, slotIdGenerator); + if (auto isConstIdExpr = dynamic_cast<ExpressionConstant*>(idExpr.get()) != nullptr; + isConstIdExpr) { + std::tie(slot, retEvalStage) = projectEvalExpr( + std::move(groupByEvalExpr), std::move(groupByEvalStage), nodeId, slotIdGenerator); + } else { + // The group-by field may end up being 'Nothing' and in that case _id: null will be + // returned. Calling 'makeFillEmptyNull' for the group-by field takes care of that. + std::tie(slot, retEvalStage) = + projectEvalExpr(makeFillEmptyNull(groupByEvalExpr.extractExpr()), + std::move(groupByEvalStage), + nodeId, + slotIdGenerator); + } return {sbe::value::SlotVector{slot}, std::move(retEvalStage), nullptr}; } @@ -2369,7 +2332,7 @@ std::tuple<sbe::value::SlotVector, EvalStage> generateAccumulator( const PlanStageSlots& childOutputs, PlanNodeId nodeId, sbe::value::SlotIdGenerator* slotIdGenerator, - sbe::SlotExprPairVector& accSlotExprPairs) { + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>>& accSlotToExprMap) { // Input fields may need field traversal which ends up being a complex tree. auto evalStage = optimizeFieldPaths( state, accStmt.expr.argument, std::move(childEvalStage), childOutputs, nodeId); @@ -2380,54 +2343,17 @@ std::tuple<sbe::value::SlotVector, EvalStage> generateAccumulator( // One accumulator may be translated to multiple accumulator expressions. For example, The // $avg will have two accumulators expressions, a sum(..) and a count which is implemented // as sum(1). - auto collatorSlot = state.data->env->getSlotIfExists("collator"_sd); - auto accExprs = stage_builder::buildAccumulator( - accStmt, std::move(argExpr), collatorSlot, *state.frameIdGenerator); + auto [accExprs, accProjEvalStage] = stage_builder::buildAccumulator( + state, accStmt, std::move(accArgEvalStage), std::move(argExpr), nodeId); sbe::value::SlotVector aggSlots; for (auto& accExpr : accExprs) { auto slot = slotIdGenerator->generate(); aggSlots.push_back(slot); - accSlotExprPairs.push_back({slot, std::move(accExpr)}); + accSlotToExprMap.emplace(slot, std::move(accExpr)); } - return {std::move(aggSlots), std::move(accArgEvalStage)}; -} - -/** - * Generate a vector of (inputSlot, mergingExpression) pairs. The slot (whose id is allocated by - * this function) will be used to store spilled partial aggregate values that have been recovered - * from disk and deserialized. The merging expression is an agg function which combines these - * partial aggregates. - * - * Usually the returned vector will be of length 1, but in some cases the MQL accumulation statement - * is implemented by calculating multiple separate aggregates in the SBE plan, which are finalized - * by a subsequent project stage to produce the ultimate value. - */ -sbe::SlotExprPairVector generateMergingExpressions(StageBuilderState& state, - const AccumulationStatement& accStmt, - int numInputSlots) { - tassert(7039555, "'numInputSlots' must be positive", numInputSlots > 0); - auto slotIdGenerator = state.slotIdGenerator; - tassert(7039556, "expected non-null 'slotIdGenerator' pointer", slotIdGenerator); - auto frameIdGenerator = state.frameIdGenerator; - tassert(7039557, "expected non-null 'frameIdGenerator' pointer", frameIdGenerator); - - auto spillSlots = slotIdGenerator->generateMultiple(numInputSlots); - auto collatorSlot = state.data->env->getSlotIfExists("collator"_sd); - auto mergingExprs = - buildCombinePartialAggregates(accStmt, spillSlots, collatorSlot, *frameIdGenerator); - - // Zip the slot vector and expression vector into a vector of pairs. - tassert(7039550, - "expected same number of slots and input exprs", - spillSlots.size() == mergingExprs.size()); - sbe::SlotExprPairVector result; - result.reserve(spillSlots.size()); - for (size_t i = 0; i < spillSlots.size(); ++i) { - result.push_back({spillSlots[i], std::move(mergingExprs[i])}); - } - return result; + return {std::move(aggSlots), std::move(accProjEvalStage)}; } std::tuple<std::vector<std::string>, sbe::value::SlotVector, EvalStage> generateGroupFinalStage( @@ -2464,11 +2390,13 @@ std::tuple<std::vector<std::string>, sbe::value::SlotVector, EvalStage> generate auto finalSlots{sbe::value::SlotVector{finalGroupBySlot}}; std::vector<std::string> fieldNames{"_id"}; + auto groupFinalEvalStage = std::move(groupEvalStage); size_t idxAccFirstSlot = dedupedGroupBySlots.size(); for (size_t idxAcc = 0; idxAcc < accStmts.size(); ++idxAcc) { // Gathers field names for the output object from accumulator statements. fieldNames.push_back(accStmts[idxAcc].fieldName); - auto finalExpr = stage_builder::buildFinalize(state, accStmts[idxAcc], aggSlotsVec[idxAcc]); + auto [finalExpr, tempEvalStage] = stage_builder::buildFinalize( + state, accStmts[idxAcc], aggSlotsVec[idxAcc], std::move(groupFinalEvalStage), nodeId); // The final step may not return an expression if it's trivial. For example, $first and // $last's final steps are trivial. @@ -2483,13 +2411,15 @@ std::tuple<std::vector<std::string>, sbe::value::SlotVector, EvalStage> generate // Some accumulator(s) like $avg generate multiple expressions and slots. So, need to // advance this index by the number of those slots for each accumulator. idxAccFirstSlot += aggSlotsVec[idxAcc].size(); + + groupFinalEvalStage = std::move(tempEvalStage); } // Gathers all accumulator results. If there're no project expressions, does not add a project // stage. auto retEvalStage = prjSlotToExprMap.empty() - ? std::move(groupEvalStage) - : makeProject(std::move(groupEvalStage), std::move(prjSlotToExprMap), nodeId); + ? std::move(groupFinalEvalStage) + : makeProject(std::move(groupFinalEvalStage), std::move(prjSlotToExprMap), nodeId); return {std::move(fieldNames), std::move(finalSlots), std::move(retEvalStage)}; } @@ -2548,8 +2478,10 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder const auto& accStmts = groupNode->accumulators; auto childStageType = childNode->getType(); - auto childReqs = reqs.copy().set(kResult); - if (childStageType == StageType::STAGE_GROUP && areAllFieldPathsOptimizable(idExpr, accStmts)) { + auto areAllTopLevelFields = checkAllFieldPathsAreTopLevel(idExpr, accStmts); + + auto childReqs = reqs.copy(); + if (childStageType == StageType::STAGE_GROUP && areAllTopLevelFields) { // Does not ask the GROUP child for the result slot to avoid unnecessary materialization if // all fields are top-level fields. See the end of this function. For example, GROUP - GROUP // - COLLSCAN case. @@ -2572,28 +2504,17 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder // Translates accumulators which are executed inside the group stage and gets slots for // accumulators. stage_builder::EvalStage accProjEvalStage = std::move(groupByEvalStage); - sbe::SlotExprPairVector accSlotExprPairs; + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> accSlotToExprMap; std::vector<sbe::value::SlotVector> aggSlotsVec; - // Since partial accumulator state may be spilled to disk and then merged, we must construct not - // only the basic agg expressions for each accumulator, but also agg expressions that are used - // to combine partial aggregates that have been spilled to disk. - sbe::SlotExprPairVector mergingExprs; for (const auto& accStmt : accStmts) { - auto [curAggSlots, tempEvalStage] = generateAccumulator(_state, - accStmt, - std::move(accProjEvalStage), - childOutputs, - nodeId, - &_slotIdGenerator, - accSlotExprPairs); - - sbe::SlotExprPairVector curMergingExprs = - generateMergingExpressions(_state, accStmt, curAggSlots.size()); - - aggSlotsVec.emplace_back(std::move(curAggSlots)); - mergingExprs.insert(mergingExprs.end(), - std::make_move_iterator(curMergingExprs.begin()), - std::make_move_iterator(curMergingExprs.end())); + auto [aggSlots, tempEvalStage] = generateAccumulator(_state, + accStmt, + std::move(accProjEvalStage), + childOutputs, + nodeId, + &_slotIdGenerator, + accSlotToExprMap); + aggSlotsVec.emplace_back(std::move(aggSlots)); accProjEvalStage = std::move(tempEvalStage); } @@ -2604,10 +2525,9 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder // Builds a group stage with accumulator expressions and group-by slot(s). auto groupEvalStage = makeHashAgg(std::move(accProjEvalStage), dedupedGroupBySlots, - std::move(accSlotExprPairs), + std::move(accSlotToExprMap), _state.data->env->getSlotIfExists("collator"_sd), _cq.getExpCtx()->allowDiskUse, - std::move(mergingExprs), nodeId); tassert( diff --git a/src/mongo/db/query/sbe_stage_builder.h b/src/mongo/db/query/sbe_stage_builder.h index d1acc2c765f..7abd0e2fa46 100644 --- a/src/mongo/db/query/sbe_stage_builder.h +++ b/src/mongo/db/query/sbe_stage_builder.h @@ -329,6 +329,9 @@ struct PlanStageData { // This holds the output slots produced by SBE plan (resultSlot, recordIdSlot, etc). PlanStageSlots outputs; + // Map from index name to IAM. + StringMap<const IndexAccessMethod*> iamMap; + // The CompileCtx object owns the RuntimeEnvironment. The RuntimeEnvironment owns various // SlotAccessors which are accessed when the SBE plan is executed. sbe::RuntimeEnvironment* env{nullptr}; @@ -376,6 +379,7 @@ private: // RuntimeEnvironment and CompileCtx. void copyFrom(const PlanStageData& other) { outputs = other.outputs; + iamMap = other.iamMap; shouldTrackLatestOplogTimestamp = other.shouldTrackLatestOplogTimestamp; shouldTrackResumeToken = other.shouldTrackResumeToken; shouldUseTailableScan = other.shouldUseTailableScan; diff --git a/src/mongo/db/query/sbe_stage_builder_accumulator.cpp b/src/mongo/db/query/sbe_stage_builder_accumulator.cpp index 0cf745c15a1..f01886c4213 100644 --- a/src/mongo/db/query/sbe_stage_builder_accumulator.cpp +++ b/src/mongo/db/query/sbe_stage_builder_accumulator.cpp @@ -42,9 +42,9 @@ namespace mongo::stage_builder { namespace { -std::unique_ptr<sbe::EExpression> wrapMinMaxArg(std::unique_ptr<sbe::EExpression> arg, - sbe::value::FrameIdGenerator& frameIdGenerator) { - return makeLocalBind(&frameIdGenerator, +std::unique_ptr<sbe::EExpression> wrapMinMaxArg(StageBuilderState& state, + std::unique_ptr<sbe::EExpression> arg) { + return makeLocalBind(state.frameIdGenerator, [](sbe::EVariable input) { return sbe::makeE<sbe::EIf>( generateNullOrMissing(input), @@ -54,37 +54,30 @@ std::unique_ptr<sbe::EExpression> wrapMinMaxArg(std::unique_ptr<sbe::EExpression std::move(arg)); } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorMin( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorMin( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; + auto collatorSlot = state.data->env->getSlotIfExists("collator"_sd); if (collatorSlot) { aggs.push_back(makeFunction("collMin"_sd, sbe::makeE<sbe::EVariable>(*collatorSlot), - wrapMinMaxArg(std::move(arg), frameIdGenerator))); + wrapMinMaxArg(state, std::move(arg)))); } else { - aggs.push_back(makeFunction("min"_sd, wrapMinMaxArg(std::move(arg), frameIdGenerator))); + aggs.push_back(makeFunction("min"_sd, wrapMinMaxArg(state, std::move(arg)))); } - return aggs; + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsMin( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeMin( + StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039501, - "partial agg combiner for $min should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorMin(expr, std::move(arg), collatorSlot, frameIdGenerator); -} - -std::unique_ptr<sbe::EExpression> buildFinalizeMin(StageBuilderState& state, - const AccumulationExpression& expr, - const sbe::value::SlotVector& minSlots) { + const sbe::value::SlotVector& minSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { // We can get away with not building a project stage since there's no finalize step but we // will stick the slot into an EVariable in case a $min is one of many group clauses and it // can be combined into a final project stage. @@ -92,104 +85,76 @@ std::unique_ptr<sbe::EExpression> buildFinalizeMin(StageBuilderState& state, str::stream() << "Expected one input slot for finalization of min, got: " << minSlots.size(), minSlots.size() == 1); - return makeFillEmptyNull(makeVariable(minSlots[0])); + return {makeFillEmptyNull(makeVariable(minSlots[0])), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorMax( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorMax( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; + auto collatorSlot = state.data->env->getSlotIfExists("collator"_sd); if (collatorSlot) { aggs.push_back(makeFunction("collMax"_sd, sbe::makeE<sbe::EVariable>(*collatorSlot), - wrapMinMaxArg(std::move(arg), frameIdGenerator))); + wrapMinMaxArg(state, std::move(arg)))); } else { - aggs.push_back(makeFunction("max"_sd, wrapMinMaxArg(std::move(arg), frameIdGenerator))); + aggs.push_back(makeFunction("max"_sd, wrapMinMaxArg(state, std::move(arg)))); } - return aggs; + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsMax( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeMax( + StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039502, - "partial agg combiner for $max should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorMax(expr, std::move(arg), collatorSlot, frameIdGenerator); -} - -std::unique_ptr<sbe::EExpression> buildFinalizeMax(StageBuilderState& state, - const AccumulationExpression& expr, - const sbe::value::SlotVector& maxSlots) { + const sbe::value::SlotVector& maxSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { tassert(5755100, str::stream() << "Expected one input slot for finalization of max, got: " << maxSlots.size(), maxSlots.size() == 1); - return makeFillEmptyNull(makeVariable(maxSlots[0])); + return {makeFillEmptyNull(makeVariable(maxSlots[0])), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorFirst( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorFirst( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; aggs.push_back(makeFunction("first", makeFillEmptyNull(std::move(arg)))); - return aggs; -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsFirst( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039503, - "partial agg combiner for $first should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorFirst(expr, std::move(arg), collatorSlot, frameIdGenerator); + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorLast( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorLast( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; aggs.push_back(makeFunction("last", makeFillEmptyNull(std::move(arg)))); - return aggs; -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsLast( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039504, - "partial agg combiner for $last should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorLast(expr, std::move(arg), collatorSlot, frameIdGenerator); + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorAvg( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorAvg( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; // 'aggDoubleDoubleSum' will ignore non-numeric values automatically. aggs.push_back(makeFunction("aggDoubleDoubleSum", arg->clone())); // For the counter we need to skip non-numeric values ourselves. - auto addend = makeLocalBind(&frameIdGenerator, + auto addend = makeLocalBind(state.frameIdGenerator, [](sbe::EVariable input) { return sbe::makeE<sbe::EIf>( makeBinaryOp(sbe::EPrimBinary::logicOr, @@ -202,27 +167,15 @@ std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorAvg( auto counterExpr = makeFunction("sum", std::move(addend)); aggs.push_back(std::move(counterExpr)); - return aggs; + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsAvg( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeAvg( + StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039539, - "partial agg combiner for $avg should have exactly two input slots", - inputSlots.size() == 2); - - std::vector<std::unique_ptr<sbe::EExpression>> aggs; - aggs.push_back(makeFunction("aggMergeDoubleDoubleSums", makeVariable(inputSlots[0]))); - aggs.push_back(makeFunction("sum", makeVariable(inputSlots[1]))); - return aggs; -} - -std::unique_ptr<sbe::EExpression> buildFinalizeAvg(StageBuilderState& state, - const AccumulationExpression& expr, - const sbe::value::SlotVector& aggSlots) { + const sbe::value::SlotVector& aggSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { // Slot 0 contains the accumulated sum, and slot 1 contains the count of summed items. tassert(5754703, str::stream() << "Expected two slots to finalize avg, got: " << aggSlots.size(), @@ -277,7 +230,7 @@ std::unique_ptr<sbe::EExpression> buildFinalizeAvg(StageBuilderState& state, auto partialAvgFinalize = sbe::makeE<sbe::EIf>(std::move(ifCondExpr), std::move(thenExpr), std::move(elseExpr)); - return partialAvgFinalize; + return {std::move(partialAvgFinalize), std::move(inputStage)}; } else { // If we've encountered any numeric input, the counter would contain a positive integer. // Unlike $sum, when there is no numeric input, $avg should return null. @@ -290,37 +243,27 @@ std::unique_ptr<sbe::EExpression> buildFinalizeAvg(StageBuilderState& state, makeFunction("doubleDoubleSumFinalize", makeVariable(aggSlots[0])), makeVariable(aggSlots[1]))); - return finalizingExpression; + return {std::move(finalizingExpression), std::move(inputStage)}; } } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorSum( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorSum( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; aggs.push_back(makeFunction("aggDoubleDoubleSum", std::move(arg))); - return aggs; + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsSum( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeSum( + StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039530, - "partial agg combiner for $sum should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - std::vector<std::unique_ptr<sbe::EExpression>> aggs; - aggs.push_back(makeFunction("aggMergeDoubleDoubleSums", std::move(arg))); - return aggs; -} - -std::unique_ptr<sbe::EExpression> buildFinalizeSum(StageBuilderState& state, - const AccumulationExpression& expr, - const sbe::value::SlotVector& sumSlots) { + const sbe::value::SlotVector& sumSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { tassert(5755300, str::stream() << "Expected one input slot for finalization of sum, got: " << sumSlots.size(), @@ -349,7 +292,8 @@ std::unique_ptr<sbe::EExpression> buildFinalizeSum(StageBuilderState& state, auto canUseNewPartialResultFormat = fcv.isVersionInitialized() && fcv.isGreaterThanOrEqualTo(multiversion::FeatureCompatibilityVersion::kVersion_6_0); if (canUseNewPartialResultFormat) { - return makeFunction("doubleDoublePartialSumFinalize", makeVariable(sumSlots[0])); + return {makeFunction("doubleDoublePartialSumFinalize", makeVariable(sumSlots[0])), + std::move(inputStage)}; } // To support the sharding behavior, the mongos splits $group into two separate $group @@ -387,60 +331,43 @@ std::unique_ptr<sbe::EExpression> buildFinalizeSum(StageBuilderState& state, input.clone()); }, std::move(sumFinalize)); - return partialSumFinalize; + return {std::move(partialSumFinalize), std::move(inputStage)}; } else { - return makeFunction("doubleDoubleSumFinalize", makeVariable(sumSlots[0])); + auto sumFinalize = makeFunction("doubleDoubleSumFinalize", makeVariable(sumSlots[0])); + return {std::move(sumFinalize), std::move(inputStage)}; } } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorAddToSetHelper( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorAddToSet( + StageBuilderState& state, + const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - StringData funcName, - boost::optional<sbe::value::SlotId> collatorSlot, - StringData funcNameWithCollator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; const int cap = internalQueryMaxAddToSetBytes.load(); + auto collatorSlot = state.data->env->getSlotIfExists("collator"_sd); if (collatorSlot) { aggs.push_back(makeFunction( - funcNameWithCollator, + "collAddToSetCapped"_sd, sbe::makeE<sbe::EVariable>(*collatorSlot), std::move(arg), makeConstant(sbe::value::TypeTags::NumberInt32, sbe::value::bitcastFrom<int>(cap)))); } else { aggs.push_back(makeFunction( - funcName, + "addToSetCapped", std::move(arg), makeConstant(sbe::value::TypeTags::NumberInt32, sbe::value::bitcastFrom<int>(cap)))); } - return aggs; -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorAddToSet( - const AccumulationExpression& expr, - std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - return buildAccumulatorAddToSetHelper( - std::move(arg), "addToSetCapped"_sd, collatorSlot, "collAddToSetCapped"_sd); -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsAddToSet( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039506, - "partial agg combiner for $addToSet should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorAddToSetHelper( - std::move(arg), "aggSetUnionCapped"_sd, collatorSlot, "aggCollSetUnionCapped"_sd); + return {std::move(aggs), std::move(inputStage)}; } -std::unique_ptr<sbe::EExpression> buildFinalizeCappedAccumulator( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeCappedAccumulator( StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& accSlots) { + const sbe::value::SlotVector& accSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { tassert(6526500, str::stream() << "Expected one input slot for finalization of capped accumulator, got: " << accSlots.size(), @@ -455,62 +382,33 @@ std::unique_ptr<sbe::EExpression> buildFinalizeCappedAccumulator( makeConstant(sbe::value::TypeTags::NumberInt32, static_cast<int>(sbe::vm::AggArrayWithSize::kValues))); - return pushFinalize; + return {std::move(pushFinalize), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorPushHelper( - std::unique_ptr<sbe::EExpression> arg, StringData aggFuncName) { +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorPush( + StageBuilderState& state, + const AccumulationExpression& expr, + std::unique_ptr<sbe::EExpression> arg, + EvalStage inputStage, + PlanNodeId planNodeId) { const int cap = internalQueryMaxPushBytes.load(); std::vector<std::unique_ptr<sbe::EExpression>> aggs; aggs.push_back(makeFunction( - aggFuncName, + "addToArrayCapped"_sd, std::move(arg), makeConstant(sbe::value::TypeTags::NumberInt32, sbe::value::bitcastFrom<int>(cap)))); - return aggs; + return {std::move(aggs), std::move(inputStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorPush( - const AccumulationExpression& expr, - std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - return buildAccumulatorPushHelper(std::move(arg), "addToArrayCapped"_sd); -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsPush( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039505, - "partial agg combiner for $push should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorPushHelper(std::move(arg), "aggConcatArraysCapped"_sd); -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorStdDev( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorStdDev( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; aggs.push_back(makeFunction("aggStdDev", std::move(arg))); - return aggs; -} - -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsStdDev( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039540, - "partial agg combiner for stddev should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - std::vector<std::unique_ptr<sbe::EExpression>> aggs; - aggs.push_back(makeFunction("aggMergeStdDevs", std::move(arg))); - return aggs; + return {std::move(aggs), std::move(inputStage)}; } std::unique_ptr<sbe::EExpression> buildFinalizePartialStdDev(sbe::value::SlotId stdDevSlot) { @@ -541,75 +439,69 @@ std::unique_ptr<sbe::EExpression> buildFinalizePartialStdDev(sbe::value::SlotId static_cast<int>(sbe::vm::AggStdDevValueElems::kCount)))}); } -std::unique_ptr<sbe::EExpression> buildFinalizeStdDevPop( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeStdDevPop( StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& stdDevSlots) { + const sbe::value::SlotVector& stdDevSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { tassert(5755204, str::stream() << "Expected one input slot for finalization of stdDevPop, got: " << stdDevSlots.size(), stdDevSlots.size() == 1); if (state.needsMerge) { - return buildFinalizePartialStdDev(stdDevSlots[0]); + return {buildFinalizePartialStdDev(stdDevSlots[0]), std::move(inputStage)}; } else { auto stdDevPopFinalize = makeFunction("stdDevPopFinalize", makeVariable(stdDevSlots[0])); - return stdDevPopFinalize; + return {std::move(stdDevPopFinalize), std::move(inputStage)}; } } -std::unique_ptr<sbe::EExpression> buildFinalizeStdDevSamp( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalizeStdDevSamp( StageBuilderState& state, const AccumulationExpression& expr, - const sbe::value::SlotVector& stdDevSlots) { + const sbe::value::SlotVector& stdDevSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { tassert(5755209, str::stream() << "Expected one input slot for finalization of stdDevSamp, got: " << stdDevSlots.size(), stdDevSlots.size() == 1); if (state.needsMerge) { - return buildFinalizePartialStdDev(stdDevSlots[0]); + return {buildFinalizePartialStdDev(stdDevSlots[0]), std::move(inputStage)}; } else { - return makeFunction("stdDevSampFinalize", makeVariable(stdDevSlots[0])); + auto stdDevSampFinalize = makeFunction("stdDevSampFinalize", makeVariable(stdDevSlots[0])); + return {std::move(stdDevSampFinalize), std::move(inputStage)}; } } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulatorMergeObjects( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulatorMergeObjects( + StageBuilderState& state, const AccumulationExpression& expr, std::unique_ptr<sbe::EExpression> arg, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { + EvalStage inputStage, + PlanNodeId planNodeId) { std::vector<std::unique_ptr<sbe::EExpression>> aggs; - auto filterExpr = - makeLocalBind(&frameIdGenerator, - [](sbe::EVariable input) { - auto typeCheckExpr = - makeBinaryOp(sbe::EPrimBinary::logicOr, - generateNullOrMissing(input), - makeFunction("isObject", input.clone())); - return sbe::makeE<sbe::EIf>( - std::move(typeCheckExpr), - makeFunction("mergeObjects", input.clone()), - sbe::makeE<sbe::EFail>(ErrorCodes::Error{5911200}, - "$mergeObjects only supports objects")); - }, - std::move(arg)); - - aggs.push_back(std::move(filterExpr)); - return aggs; -} + auto filterExpr = makeLocalBind( + state.frameIdGenerator, + [](sbe::EVariable input) { + return makeBinaryOp( + sbe::EPrimBinary::logicOr, + generateNullOrMissing(input), + makeBinaryOp(sbe::EPrimBinary::logicOr, + makeFunction("isObject", input.clone()), + sbe::makeE<sbe::EFail>(ErrorCodes::Error{5911200}, + "$mergeObjects only supports objects"))); + }, + arg->clone()); -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggsMergeObjects( - const AccumulationExpression& expr, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - tassert(7039507, - "partial agg combiner for $mergeObjects should have exactly one input slot", - inputSlots.size() == 1); - auto arg = makeVariable(inputSlots[0]); - return buildAccumulatorMergeObjects(expr, std::move(arg), collatorSlot, frameIdGenerator); + inputStage = makeFilter<false>(std::move(inputStage), std::move(filterExpr), planNodeId); + + aggs.push_back(makeFunction("mergeObjects", std::move(arg))); + return {std::move(aggs), std::move(inputStage)}; } }; // namespace @@ -624,16 +516,19 @@ std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildArgument( return {argExpr.extractExpr(), std::move(outStage)}; } -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulator( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulator( + StageBuilderState& state, const AccumulationStatement& acc, - std::unique_ptr<sbe::EExpression> argExpr, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - using BuildAccumulatorFn = std::function<std::vector<std::unique_ptr<sbe::EExpression>>( - const AccumulationExpression&, - std::unique_ptr<sbe::EExpression>, - boost::optional<sbe::value::SlotId>, - sbe::value::FrameIdGenerator&)>; + EvalStage inputStage, + std::unique_ptr<sbe::EExpression> inputExpr, + PlanNodeId planNodeId) { + using BuildAccumulatorFn = + std::function<std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage>( + StageBuilderState&, + const AccumulationExpression&, + std::unique_ptr<sbe::EExpression>, + EvalStage, + PlanNodeId)>; static const StringDataMap<BuildAccumulatorFn> kAccumulatorBuilders = { {AccumulatorMin::kName, &buildAccumulatorMin}, @@ -655,51 +550,25 @@ std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulator( kAccumulatorBuilders.find(accExprName) != kAccumulatorBuilders.end()); return std::invoke(kAccumulatorBuilders.at(accExprName), + state, acc.expr, - std::move(argExpr), - collatorSlot, - frameIdGenerator); + std::move(inputExpr), + std::move(inputStage), + planNodeId); } -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggregates( +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalize( + StageBuilderState& state, const AccumulationStatement& acc, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator& frameIdGenerator) { - using BuildAggCombinerFn = std::function<std::vector<std::unique_ptr<sbe::EExpression>>( + const sbe::value::SlotVector& aggSlots, + EvalStage inputStage, + PlanNodeId planNodeId) { + using BuildFinalizeFn = std::function<std::pair<std::unique_ptr<sbe::EExpression>, EvalStage>( + StageBuilderState&, const AccumulationExpression&, - const sbe::value::SlotVector&, - boost::optional<sbe::value::SlotId>, - sbe::value::FrameIdGenerator&)>; - - static const StringDataMap<BuildAggCombinerFn> kAggCombinerBuilders = { - {AccumulatorAddToSet::kName, &buildCombinePartialAggsAddToSet}, - {AccumulatorAvg::kName, &buildCombinePartialAggsAvg}, - {AccumulatorFirst::kName, &buildCombinePartialAggsFirst}, - {AccumulatorLast::kName, &buildCombinePartialAggsLast}, - {AccumulatorMax::kName, &buildCombinePartialAggsMax}, - {AccumulatorMergeObjects::kName, &buildCombinePartialAggsMergeObjects}, - {AccumulatorMin::kName, &buildCombinePartialAggsMin}, - {AccumulatorPush::kName, &buildCombinePartialAggsPush}, - {AccumulatorStdDevPop::kName, &buildCombinePartialAggsStdDev}, - {AccumulatorStdDevSamp::kName, &buildCombinePartialAggsStdDev}, - {AccumulatorSum::kName, &buildCombinePartialAggsSum}, - }; - - auto accExprName = acc.expr.name; - uassert(7039500, - str::stream() << "Unsupported Accumulator in SBE accumulator builder: " << accExprName, - kAggCombinerBuilders.find(accExprName) != kAggCombinerBuilders.end()); - - return std::invoke( - kAggCombinerBuilders.at(accExprName), acc.expr, inputSlots, collatorSlot, frameIdGenerator); -} - -std::unique_ptr<sbe::EExpression> buildFinalize(StageBuilderState& state, - const AccumulationStatement& acc, - const sbe::value::SlotVector& aggSlots) { - using BuildFinalizeFn = std::function<std::unique_ptr<sbe::EExpression>( - StageBuilderState&, const AccumulationExpression&, sbe::value::SlotVector)>; + sbe::value::SlotVector, + EvalStage, + PlanNodeId)>; static const StringDataMap<BuildFinalizeFn> kAccumulatorBuilders = { {AccumulatorMin::kName, &buildFinalizeMin}, @@ -721,10 +590,10 @@ std::unique_ptr<sbe::EExpression> buildFinalize(StageBuilderState& state, kAccumulatorBuilders.find(accExprName) != kAccumulatorBuilders.end()); if (auto fn = kAccumulatorBuilders.at(accExprName); fn) { - return std::invoke(fn, state, acc.expr, aggSlots); + return std::invoke(fn, state, acc.expr, aggSlots, std::move(inputStage), planNodeId); } else { // nullptr for 'EExpression' signifies that no final project is necessary. - return nullptr; + return {nullptr, std::move(inputStage)}; } } } // namespace mongo::stage_builder diff --git a/src/mongo/db/query/sbe_stage_builder_accumulator.h b/src/mongo/db/query/sbe_stage_builder_accumulator.h index 7477ffb2a3a..508a34f07f0 100644 --- a/src/mongo/db/query/sbe_stage_builder_accumulator.h +++ b/src/mongo/db/query/sbe_stage_builder_accumulator.h @@ -51,32 +51,24 @@ std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildArgument( /** * Translates an input AccumulationStatement into an SBE EExpression for accumulation expressions. + * The 'stage' parameter provides the input subtree to build on top of. */ -std::vector<std::unique_ptr<sbe::EExpression>> buildAccumulator( +std::pair<std::vector<std::unique_ptr<sbe::EExpression>>, EvalStage> buildAccumulator( + StageBuilderState& state, const AccumulationStatement& acc, + EvalStage stage, std::unique_ptr<sbe::EExpression> argExpr, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator&); - -/** - * When SBE hash aggregation spills to disk, it spills partial aggregates which need to be combined - * later. This function returns the expressions that can be used to combine partial aggregates for - * the given accumulator 'acc'. The aggregate-of-aggregates will be stored in a slots owned by the - * hash agg stage, while the new partial aggregates to combine can be read from the given - * 'inputSlots'. - */ -std::vector<std::unique_ptr<sbe::EExpression>> buildCombinePartialAggregates( - const AccumulationStatement& acc, - const sbe::value::SlotVector& inputSlots, - boost::optional<sbe::value::SlotId> collatorSlot, - sbe::value::FrameIdGenerator&); + PlanNodeId planNodeId); /** * Translates an input AccumulationStatement into an SBE EExpression that represents an * AccumulationStatement's finalization step. The 'stage' parameter provides the input subtree to * build on top of. */ -std::unique_ptr<sbe::EExpression> buildFinalize(StageBuilderState& state, - const AccumulationStatement& acc, - const sbe::value::SlotVector& aggSlots); +std::pair<std::unique_ptr<sbe::EExpression>, EvalStage> buildFinalize( + StageBuilderState& state, + const AccumulationStatement& acc, + const sbe::value::SlotVector& aggSlots, + EvalStage stage, + PlanNodeId planNodeId); } // namespace mongo::stage_builder diff --git a/src/mongo/db/query/sbe_stage_builder_accumulator_test.cpp b/src/mongo/db/query/sbe_stage_builder_accumulator_test.cpp index 732b04f62a8..e4fd17df36d 100644 --- a/src/mongo/db/query/sbe_stage_builder_accumulator_test.cpp +++ b/src/mongo/db/query/sbe_stage_builder_accumulator_test.cpp @@ -27,22 +27,15 @@ * it in the license file. */ -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - #include "mongo/platform/basic.h" #include <fmt/printf.h> -#include "mongo/db/exec/sbe/expression_test_base.h" -#include "mongo/db/exec/sbe/values/value_printer.h" #include "mongo/db/pipeline/document_source_group.h" #include "mongo/db/pipeline/expression_context_for_test.h" #include "mongo/db/query/collation/collator_interface_mock.h" #include "mongo/db/query/query_solution.h" -#include "mongo/db/query/sbe_stage_builder_accumulator.h" #include "mongo/db/query/sbe_stage_builder_test_fixture.h" -#include "mongo/idl/server_parameter_test_util.h" -#include "mongo/logv2/log.h" #include "mongo/unittest/unittest.h" namespace mongo { @@ -1684,724 +1677,4 @@ TEST_F(SbeStageBuilderGroupTest, SbeIncompatibleExpressionInGroup) { } } -/** - * A test fixture designed to test that the expressions generated to combine partial aggregates - * that have been spilled to disk work correctly. We use 'EExpressionTestFixture' rather than - * something like 'SbeStageBuilderTestFixture' so that the expressions can be tested in isolation, - * without actually requiring a hash agg stage or without actually spilling any data to disk. - */ -class SbeStageBuilderGroupAggCombinerTest : public sbe::EExpressionTestFixture { -public: - explicit SbeStageBuilderGroupAggCombinerTest() - : _expCtx{make_intrusive<ExpressionContextForTest>()}, - _inputSlotId{bindAccessor(&_inputAccessor)}, - _collatorSlotId{bindAccessor(&_collatorAccessor)} {} - - AccumulationStatement makeAccumulationStatement(StringData accumName) { - return makeAccumulationStatement(BSON("unused" << BSON(accumName << "unused"))); - } - - AccumulationStatement makeAccumulationStatement(BSONObj accumulationStmt) { - _accumulationStmtBson = std::move(accumulationStmt); - VariablesParseState vps = _expCtx->variablesParseState; - return AccumulationStatement::parseAccumulationStatement( - _expCtx.get(), _accumulationStmtBson.firstElement(), vps); - } - - /** - * Convenience method for producing bytecode which combines partial aggregates for the given - * 'AccumulationStatement'. - * - * Requires that accumulation statement results in a single aggregate with one input and one - * output. Furthermore, cannot be used when the test case involves a non-simple collation. - */ - std::unique_ptr<sbe::vm::CodeFragment> compileSingleInputNoCollator( - const AccumulationStatement& accStatement) { - auto exprs = stage_builder::buildCombinePartialAggregates( - accStatement, {_inputSlotId}, boost::none, _frameIdGenerator); - ASSERT_EQ(exprs.size(), 1u); - _expr = std::move(exprs[0]); - - return compileAggExpression(*_expr, &_aggAccessor); - } - - /** - * Verifies that executing the bytecode ('code') for combining partial aggregates for $group - * spilling produces the 'expected' outputs given 'inputs'. - * - * The inputs and expected outputs are expressed as BSON arrays as a convenience to the caller, - * and should have the same length. The bytecode is executed over each element of 'inputs' - * one-by-one, with the result stored into a slot holding the aggregate value. At each step, - * this function asserts that the current aggregate value is equal to the matching element in - * 'expected'. - * - * The string "MISSING" can be used as a sentinel in either 'inputs' or 'outputs' in order to - * represent the Nothing value (since nothingness cannot literally be stored in a BSON array). - */ - void aggregateAndAssertResults(BSONArray inputs, - BSONArray expected, - const sbe::vm::CodeFragment* code) { - auto [inputTag, inputVal] = makeArray(inputs); - auto [expectedTag, expectedVal] = makeArray(expected); - return aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, code); - } - - /** - * Verifies that executing the bytecode ('code') for combining partial aggregates for $group - * spilling produces the 'expectedVal' outputs given 'inputsVal'. Assumes ownership of both - * 'expectedVal' and 'inputsVal'. - * - * Identical to the overload above, except the inputs and expected outputs are provided as SBE - * arrays rather than BSON arrays. This is useful if the caller needs to construct input and - * output ways in a special way that cannot be achieved by trivial conversion from BSON. - */ - void aggregateAndAssertResults(sbe::value::TypeTags inputTag, - sbe::value::Value inputVal, - sbe::value::TypeTags expectedTag, - sbe::value::Value expectedVal, - const sbe::vm::CodeFragment* code) { - // Make sure we are starting from a clean state. - _inputAccessor.reset(); - _aggAccessor.reset(); - - sbe::value::ValueGuard inputGuard{inputTag, inputVal}; - sbe::value::ValueGuard expectedGuard{expectedTag, expectedVal}; - - sbe::value::ArrayEnumerator inputEnumerator{inputTag, inputVal}; - sbe::value::ArrayEnumerator expectedEnumerator{expectedTag, expectedVal}; - - // Aggregate the inputs one-by-one, and at each step validate that the resulting accumulator - // state is as expected. - int index = 0; - while (!inputEnumerator.atEnd()) { - ASSERT_FALSE(expectedEnumerator.atEnd()); - auto [nextInputTag, nextInputVal] = inputEnumerator.getViewOfValue(); - - // Feed in the input value, treating "MISSING" as a special sentinel to indicate the - // Nothing value. - if (sbe::value::isString(nextInputTag) && - sbe::value::getStringView(nextInputTag, nextInputVal) == "MISSING"_sd) { - _inputAccessor.reset(); - } else { - auto [copyTag, copyVal] = sbe::value::copyValue(nextInputTag, nextInputVal); - _inputAccessor.reset(true, copyTag, copyVal); - } - - auto [outputTag, outputVal] = runCompiledExpression(code); - - // Validate that the output value equals the expected value, and then put the output - // value into the slot that holds the accumulation state. - auto [expectedOutputTag, expectedOutputValue] = expectedEnumerator.getViewOfValue(); - if (sbe::value::isString(expectedOutputTag) && - sbe::value::getStringView(expectedOutputTag, expectedOutputValue) == "MISSING"_sd) { - expectedOutputTag = sbe::value::TypeTags::Nothing; - expectedOutputValue = 0; - } - auto [compareTag, compareValue] = sbe::value::compareValue( - outputTag, outputVal, expectedOutputTag, expectedOutputValue); - if (compareTag != sbe::value::TypeTags::NumberInt32 || compareValue != 0) { - // The test failed, but dump the actual and expected values to the logs for ease of - // debugging. - str::stream actualBuilder; - auto actualPrinter = makeValuePrinter(actualBuilder); - actualPrinter.writeValueToStream(outputTag, outputVal); - - str::stream expectedBuilder; - auto expectedPrinter = makeValuePrinter(expectedBuilder); - expectedPrinter.writeValueToStream(expectedOutputTag, expectedOutputValue); - - LOGV2(7039529, - "Actual value not equal to expected value", - "actual"_attr = actualBuilder, - "expected"_attr = expectedBuilder, - "index"_attr = index); - FAIL("accumulator did not have expected value"); - } - - _aggAccessor.reset(true, outputTag, outputVal); - - inputEnumerator.advance(); - expectedEnumerator.advance(); - ++index; - } - } - - /** - * A helper for converting a sequence of accumulator states for $push or $addToSet into the - * corresponding SBE value. - */ - enum class Accumulator { kPush, kAddToSet }; - std::pair<sbe::value::TypeTags, sbe::value::Value> makeArrayAccumVal(BSONArray bsonArray, - Accumulator accumType) { - auto [resultTag, resultVal] = sbe::value::makeNewArray(); - sbe::value::ValueGuard resultGuard{resultTag, resultVal}; - auto resultArr = sbe::value::getArrayView(resultVal); - - for (auto&& elt : bsonArray) { - ASSERT(elt.type() == BSONType::Array); - - BSONObjIterator arrayIt{elt.embeddedObject()}; - ASSERT_TRUE(arrayIt.more()); - auto firstElt = arrayIt.next(); - ASSERT(firstElt.type() == BSONType::Array); - BSONArray partialBsonArr{firstElt.embeddedObject()}; - - ASSERT_TRUE(arrayIt.more()); - auto secondElt = arrayIt.next(); - ASSERT(secondElt.isNumber()); - int64_t size = secondElt.safeNumberLong(); - - ASSERT_FALSE(arrayIt.more()); - - // Each partial aggregate is a two-element array whose first element is the partial - // $push result (itself an array) and whose second element is the size. - auto [partialAggTag, partialAggVal] = sbe::value::makeNewArray(); - auto partialAggArr = sbe::value::getArrayView(partialAggVal); - - auto [pushedValsTag, pushedValsVal] = accumType == Accumulator::kPush - ? makeArray(partialBsonArr) - : makeArraySet(partialBsonArr); - partialAggArr->push_back(pushedValsTag, pushedValsVal); - - partialAggArr->push_back(sbe::value::TypeTags::NumberInt64, - sbe::value::bitcastFrom<int64_t>(size)); - - resultArr->push_back(partialAggTag, partialAggVal); - } - - resultGuard.reset(); - return {resultTag, resultVal}; - } - - /** - * Given the name of an SBE agg function ('aggFuncName') and an array of values expressed as a - * BSON array, aggregates the values inside the array and returns the resulting SBE value. - */ - std::pair<sbe::value::TypeTags, sbe::value::Value> makeOnePartialAggregate( - StringData aggFuncName, BSONArray valuesToAgg) { - // Make sure we are starting from a clean state. - _inputAccessor.reset(); - _aggAccessor.reset(); - - // Construct an expression which calls the given agg function, aggregating the values in - // '_inputSlotId'. - auto expr = - stage_builder::makeFunction(aggFuncName, stage_builder::makeVariable(_inputSlotId)); - auto code = compileAggExpression(*expr, &_aggAccessor); - - // Find the first element by skipping the length. - const char* bsonElt = valuesToAgg.objdata() + 4; - const char* bsonEnd = bsonElt + valuesToAgg.objsize(); - while (*bsonElt != 0) { - auto fieldName = sbe::bson::fieldNameView(bsonElt); - - // Convert the BSON value to an SBE value and put it inside the input slot. - auto [tag, val] = sbe::bson::convertFrom<false>(bsonElt, bsonEnd, fieldName.size()); - _inputAccessor.reset(true, tag, val); - - // Run the agg function, and put the result in the slot holding the aggregate value. - auto [outputTag, outputVal] = runCompiledExpression(code.get()); - _aggAccessor.reset(true, outputTag, outputVal); - - bsonElt = sbe::bson::advance(bsonElt, fieldName.size()); - } - - return _aggAccessor.copyOrMoveValue(); - } - - /** - * Returns an SBE array which contains a sequence of partial aggregate values. Useful for - * constructing a sequence of partial aggregates when those partial aggregates are not trivial - * to describe using BSON. The input to this function is a BSON array of BSON arrays; each of - * the inner arrays is aggregated using the given 'aggFuncName' in order to produce the output - * SBE array. - * - * As an example, suppose the agg function is a simple sum. Given the input - * - * [[8, 1, 5], [6], [2,3]] - * - * the output will be the SBE array [14, 6, 5]. - */ - std::pair<sbe::value::TypeTags, sbe::value::Value> makePartialAggArray( - StringData aggFuncName, BSONArray arrayOfArrays) { - auto [arrTag, arrVal] = sbe::value::makeNewArray(); - sbe::value::ValueGuard guard{arrTag, arrVal}; - - auto arr = sbe::value::getArrayView(arrVal); - - for (auto&& element : arrayOfArrays) { - ASSERT(element.type() == BSONType::Array); - auto [tag, val] = - makeOnePartialAggregate(aggFuncName, BSONArray{element.embeddedObject()}); - arr->push_back(tag, val); - } - - guard.reset(); - return {arrTag, arrVal}; - } - -protected: - sbe::value::FrameIdGenerator _frameIdGenerator; - boost::intrusive_ptr<ExpressionContextForTest> _expCtx; - - // Accessor and corresponding slot id that holds the input to the agg expression. Each time we - // "turn the crank" this will hold the next partial aggregate to be aggregated into - // '_aggAccessor'. - sbe::value::OwnedValueAccessor _inputAccessor; - sbe::value::SlotId _inputSlotId; - - // The accessor which holds the final output resulting from combining all partial outputs. We - // check that the intermediate value is as expected after every turn of the crank. - sbe::value::OwnedValueAccessor _aggAccessor; - - sbe::value::OwnedValueAccessor _collatorAccessor; - sbe::value::SlotId _collatorSlotId; - -private: - template <typename Stream> - sbe::value::ValuePrinter<Stream> makeValuePrinter(Stream& stream) { - return sbe::value::ValuePrinters::make(stream, - sbe::PrintOptions().useTagForAmbiguousValues(true)); - } - - BSONObj _accumulationStmtBson; - std::unique_ptr<sbe::EExpression> _expr; -}; - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsMin) { - auto accStatement = makeAccumulationStatement("$min"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto inputValues = BSON_ARRAY(8 << 7 << 9 << BSONNULL << 6); - auto expectedAggStates = BSON_ARRAY(8 << 7 << 7 << 7 << 6); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); - - // Test that Nothing values are treated as expected. - inputValues = BSON_ARRAY("MISSING" << 9 << 7 << "MISSING" << 6); - expectedAggStates = BSON_ARRAY("MISSING" << 9 << 7 << 7 << 6); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsMinWithCollation) { - auto accStatement = makeAccumulationStatement("$min"_sd); - - auto exprs = stage_builder::buildCombinePartialAggregates( - accStatement, {_inputSlotId}, {_collatorSlotId}, _frameIdGenerator); - ASSERT_EQ(exprs.size(), 1u); - auto expr = std::move(exprs[0]); - - CollatorInterfaceMock collator{CollatorInterfaceMock::MockType::kReverseString}; - _collatorAccessor.reset(false, - sbe::value::TypeTags::collator, - sbe::value::bitcastFrom<const CollatorInterface*>(&collator)); - - auto compiledExpr = compileAggExpression(*expr, &_aggAccessor); - - // The strings in reverse have the opposite ordering as compared to forwards. - auto inputValues = BSON_ARRAY("az" - << "by" - << "cx"); - auto expectedAggStates = BSON_ARRAY("az" - << "by" - << "cx"); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsMax) { - auto accStatement = makeAccumulationStatement("$max"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto inputValues = BSON_ARRAY(3 << 1 << 4 << BSONNULL << 8); - auto expectedAggStates = BSON_ARRAY(3 << 3 << 4 << 4 << 8); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); - - // Test that Nothing values are treated as expected. - inputValues = BSON_ARRAY("MISSING" << 7 << 9 << "MISSING" << 10); - expectedAggStates = BSON_ARRAY("MISSING" << 7 << 9 << 9 << 10); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsMaxWithCollation) { - auto accStatement = makeAccumulationStatement("$max"_sd); - - auto exprs = stage_builder::buildCombinePartialAggregates( - accStatement, {_inputSlotId}, {_collatorSlotId}, _frameIdGenerator); - ASSERT_EQ(exprs.size(), 1u); - auto expr = std::move(exprs[0]); - - CollatorInterfaceMock collator{CollatorInterfaceMock::MockType::kReverseString}; - _collatorAccessor.reset(false, - sbe::value::TypeTags::collator, - sbe::value::bitcastFrom<const CollatorInterface*>(&collator)); - - auto compiledExpr = compileAggExpression(*expr, &_aggAccessor); - - // The strings in reverse have the opposite ordering as compared to forwards. - auto inputValues = BSON_ARRAY("cx" - << "by" - << "az"); - auto expectedAggStates = BSON_ARRAY("cx" - << "by" - << "az"); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsFirst) { - auto accStatement = makeAccumulationStatement("$first"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto inputValues = BSON_ARRAY(3 << 1 << BSONNULL << "MISSING" << 8); - auto expectedAggStates = BSON_ARRAY(3 << 3 << 3 << 3 << 3); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); - - // When the first value is missing, the resulting value is a literal null. - inputValues = BSON_ARRAY("MISSING" << 1 << BSONNULL << "MISSING" << 8); - expectedAggStates = BSON_ARRAY(BSONNULL << BSONNULL << BSONNULL << BSONNULL << BSONNULL); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsLast) { - auto accStatement = makeAccumulationStatement("$last"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto inputValues = BSON_ARRAY(3 << 1 << BSONNULL << "MISSING" << 8); - auto expectedAggStates = BSON_ARRAY(3 << 1 << BSONNULL << BSONNULL << 8); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsPush) { - auto accStatement = makeAccumulationStatement("$push"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto [inputValuesTag, inputValuesVal] = makeArrayAccumVal( - BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(5 << 4 << 3) << 10) - << BSON_ARRAY(BSON_ARRAY(2 << 1) << 20) << BSON_ARRAY(BSONArray{} << 0)), - Accumulator::kPush); - auto [expectedTag, expectedVal] = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(5 << 4 << 3) << 10) - << BSON_ARRAY(BSON_ARRAY(5 << 4 << 3 << 2 << 1) << 30) - << BSON_ARRAY(BSON_ARRAY(5 << 4 << 3 << 2 << 1) << 30)), - Accumulator::kPush); - aggregateAndAssertResults( - inputValuesTag, inputValuesVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsPushThrowsWhenExceedingSizeLimit) { - auto accStatement = makeAccumulationStatement("$push"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - // If we inject a very large size, we expect the accumulator to throw. This cap prevents the - // accumulator from consuming too much memory. - const int64_t largeSize = 1000 * 1000 * 1000; - - auto input = makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(5 << 4) << 3) - << BSON_ARRAY(BSON_ARRAY(2 << 1) << largeSize)), - Accumulator::kPush); - auto expected = makeArrayAccumVal( - BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(5 << 4) << 3) << BSON_ARRAY(BSON_ARRAY("unused") << -1)), - Accumulator::kPush); - ASSERT_THROWS_CODE( - aggregateAndAssertResults( - input.first, input.second, expected.first, expected.second, compiledExpr.get()), - DBException, - ErrorCodes::ExceededMemoryLimit); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsAddToSet) { - auto accStatement = makeAccumulationStatement("$addToSet"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto [inputValuesTag, inputValuesVal] = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(3 << 4 << 5) << 10) - << BSON_ARRAY(BSON_ARRAY(1 << 3 << 5 << 8) << 20) - << BSON_ARRAY(BSONArray{} << 0)), - Accumulator::kAddToSet); - - // Each SBE value is 8 bytes and its tag is 1 byte. So we expect each unique element's size to - // be calculated as 9 bytes. The sizes from the partial aggregates end up getting ignored, and - // the total size is recalculated, since we cannot predict the size of the set union in advance. - auto [expectedTag, expectedVal] = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(3 << 4 << 5) << 27) - << BSON_ARRAY(BSON_ARRAY(1 << 3 << 4 << 5 << 8) << 45) - << BSON_ARRAY(BSON_ARRAY(1 << 3 << 4 << 5 << 8) << 45)), - Accumulator::kAddToSet); - aggregateAndAssertResults( - inputValuesTag, inputValuesVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsAddToSetWithCollation) { - auto accStatement = makeAccumulationStatement("$addToSet"_sd); - - auto exprs = stage_builder::buildCombinePartialAggregates( - accStatement, {_inputSlotId}, {_collatorSlotId}, _frameIdGenerator); - ASSERT_EQ(exprs.size(), 1u); - auto expr = std::move(exprs[0]); - - CollatorInterfaceMock collator{CollatorInterfaceMock::MockType::kToLowerString}; - _collatorAccessor.reset(false, - sbe::value::TypeTags::collator, - sbe::value::bitcastFrom<const CollatorInterface*>(&collator)); - - auto compiledExpr = compileAggExpression(*expr, &_aggAccessor); - - auto [inputValuesTag, inputValuesVal] = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY("foo" - << "bar") - << 10) - << BSON_ARRAY(BSON_ARRAY("FOO" - << "BAR" - << "baz") - << 20)), - Accumulator::kAddToSet); - - // These strings end up as big strings copied out of the BSON array, so the size accounts for - // the value itself, the type tag, the 4-byte size of the string, and the string itself. - auto [expectedTag, expectedVal] = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY("bar" - << "foo") - << 34) - << BSON_ARRAY(BSON_ARRAY("bar" - << "baz" - << "foo") - << 51)), - Accumulator::kAddToSet); - aggregateAndAssertResults( - inputValuesTag, inputValuesVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, - CombinePartialAggsAddToSetThrowsWhenExceedingSizeLimit) { - RAIIServerParameterControllerForTest queryKnobController("internalQueryMaxAddToSetBytes", 50); - - auto accStatement = makeAccumulationStatement("$addToSet"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto input = makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(1 << 2) << 0) - << BSON_ARRAY(BSON_ARRAY(3 << 4 << 5) << 0) - << BSON_ARRAY(BSON_ARRAY(6) << 0)), - Accumulator::kAddToSet); - - auto expected = - makeArrayAccumVal(BSON_ARRAY(BSON_ARRAY(BSON_ARRAY(1 << 2) << 18) - << BSON_ARRAY(BSON_ARRAY(1 << 2 << 3 << 4 << 5) << 45) - << BSON_ARRAY(BSON_ARRAY("unused") << -1)), - Accumulator::kAddToSet); - - ASSERT_THROWS_CODE( - aggregateAndAssertResults( - input.first, input.second, expected.first, expected.second, compiledExpr.get()), - DBException, - ErrorCodes::ExceededMemoryLimit); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsMergeObjects) { - auto accStatement = makeAccumulationStatement("$mergeObjects"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - auto inputValues = BSON_ARRAY(BSONNULL << BSONObj{} << BSON("a" << 1) << BSONNULL << "MISSING" - << BSON("a" << 2 << "b" << 3 << "c" << 4) << BSONObj{}); - auto expectedAggStates = - BSON_ARRAY(BSONObj{} << BSONObj{} << BSON("a" << 1) << BSON("a" << 1) << BSON("a" << 1) - << BSON("a" << 2 << "b" << 3 << "c" << 4) - << BSON("a" << 2 << "b" << 3 << "c" << 4)); - aggregateAndAssertResults(inputValues, expectedAggStates, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsSimpleCount) { - // $sum:1 is a simple count of the incoming documents. SERVER-65465 changed this scenario to use - // a simple summation rather than the DoubleDouble summation algorithm in more recent branches, - // but the 6.0 branch still uses DoubleDouble sum. - auto inputValues = BSON_ARRAY(5 << 8 << "MISSING" << 4); - auto [inputTag, inputVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, BSON_ARRAY(BSON_ARRAY(5) << BSON_ARRAY(8) << BSON_ARRAY(4))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(5) << BSON_ARRAY(5 << 8) << BSON_ARRAY(5 << 8 << 4))); - - auto accStatement = makeAccumulationStatement(BSON("unused" << BSON("$sum" << 1))); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsDoubleDoubleSum) { - auto [inputTag, inputVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2 << 3) << BSON_ARRAY(4 << 6) << BSON_ARRAY(1 << 1 << 1))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, BSON_ARRAY(BSON_ARRAY(6) << BSON_ARRAY(16) << BSON_ARRAY(19))); - - // A field path expression is needed so that the merging expression is constructed to combine - // DoubleDouble summations rather than doing a simple sum. The actual field name "foo" is - // irrelevant because the values are fed into the merging expression by the test fixture. - auto accStatement = makeAccumulationStatement(BSON("unused" << BSON("$sum" - << "$foo"))); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsDoubleDoubleSumInfAndNan) { - auto [inputTag, inputVal] = - makePartialAggArray("aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2 << 3) - << BSON_ARRAY(4 << std::numeric_limits<double>::infinity()) - << BSON_ARRAY(1 << 1 << 1) - << BSON_ARRAY(std::numeric_limits<double>::quiet_NaN()))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(6) << BSON_ARRAY(10 << std::numeric_limits<double>::infinity()) - << BSON_ARRAY(10 << std::numeric_limits<double>::infinity()) - << BSON_ARRAY(std::numeric_limits<double>::quiet_NaN()))); - - // A field path expression is needed so that the merging expression is constructed to combine - // DoubleDouble summations rather than doing a simple sum. The actual field name "foo" is - // irrelevant because the values are fed into the merging expression by the test fixture. - auto accStatement = makeAccumulationStatement(BSON("unused" << BSON("$sum" - << "$foo"))); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsDoubleDoubleSumMixedTypes) { - auto [inputTag, inputVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2) << BSON_ARRAY(3ll << 4ll) << BSON_ARRAY(5.5 << 6.6) - << BSON_ARRAY(Decimal128(7) << Decimal128(8)))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2) << BSON_ARRAY(1 << 2 << 3ll << 4ll) - << BSON_ARRAY(1 << 2 << 3ll << 4ll << 5.5 << 6.6) - << BSON_ARRAY(1 << 2 << 3ll << 4ll << 5.5 << 6.6 - << Decimal128(7) << Decimal128(8)))); - - // A field path expression is needed so that the merging expression is constructed to combine - // DoubleDouble summations rather than doing a simple sum. The actual field name "foo" is - // irrelevant because the values are fed into the merging expression by the test fixture. - auto accStatement = makeAccumulationStatement(BSON("unused" << BSON("$sum" - << "$foo"))); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsDoubleDoubleSumLargeInts) { - // Large 64-bit ints can't be represented precisely as doubles. This test demonstrates that when - // summing such large longs, the sum is returned as a long and no precision is lost. - const int64_t largeLong = std::numeric_limits<int64_t>::max() - 10; - - auto [inputTag, inputVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(largeLong << 1 << 1) << BSON_ARRAY(1ll << 1ll << 1ll))); - auto [expectedTag, expectedVal] = - makePartialAggArray("aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(largeLong + 2ll) << BSON_ARRAY(largeLong + 5ll))); - - // A field path expression is needed so that the merging expression is constructed to combine - // DoubleDouble summations rather than doing a simple sum. The actual field name "foo" is - // irrelevant because the values are fed into the merging expression by the test fixture. - auto accStatement = makeAccumulationStatement(BSON("unused" << BSON("$sum" - << "$foo"))); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); - - // Feed the result back into the input accessor. We finalize the resulting aggregate in order - // to make sure that the resulting sum is mathematically correct. - auto [resTag, resVal] = _aggAccessor.copyOrMoveValue(); - _inputAccessor.reset(true, resTag, resVal); - auto finalizeExpr = stage_builder::makeFunction("doubleDoubleSumFinalize", - stage_builder::makeVariable(_inputSlotId)); - auto finalizeCode = compileExpression(*finalizeExpr); - auto [finalizedTag, finalizedRes] = runCompiledExpression(finalizeCode.get()); - ASSERT_EQ(finalizedTag, sbe::value::TypeTags::NumberInt64); - ASSERT_EQ(sbe::value::bitcastTo<int64_t>(finalizedRes), largeLong + 5ll); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsAvg) { - auto accStatement = makeAccumulationStatement("$avg"_sd); - - // We expect $avg to result in two separate agg expressions: one for computing the sum and the - // other for computing the count. Both agg expressions read from the same input slot. - auto exprs = stage_builder::buildCombinePartialAggregates( - accStatement, {_inputSlotId, _inputSlotId}, boost::none, _frameIdGenerator); - ASSERT_EQ(exprs.size(), 2u); - - // Compile the first expression and make sure it can combine DoubleDouble summations as - // expected. - auto [inputTag, inputVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2) << BSON_ARRAY(3ll << 4ll) << BSON_ARRAY(5.5 << 6.6) - << BSON_ARRAY(Decimal128(7) << Decimal128(8)))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggDoubleDoubleSum"_sd, - BSON_ARRAY(BSON_ARRAY(1 << 2) << BSON_ARRAY(1 << 2 << 3ll << 4ll) - << BSON_ARRAY(1 << 2 << 3ll << 4ll << 5.5 << 6.6) - << BSON_ARRAY(1 << 2 << 3ll << 4ll << 5.5 << 6.6 - << Decimal128(7) << Decimal128(8)))); - auto doubleDoubleSumExpr = compileAggExpression(*exprs[0], &_aggAccessor); - aggregateAndAssertResults( - inputTag, inputVal, expectedTag, expectedVal, doubleDoubleSumExpr.get()); - - // Now compile the second expression and make sure it computes a simple sum. - auto simpleSumExpr = compileAggExpression(*exprs[1], &_aggAccessor); - - auto inputValues = BSON_ARRAY(5 << 8 << 0 << 4); - auto expectedAggStates = BSON_ARRAY(5 << 13 << 13 << 17); - aggregateAndAssertResults(inputValues, expectedAggStates, simpleSumExpr.get()); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsStdDevPop) { - auto [inputTag, inputVal] = makePartialAggArray( - "aggStdDev"_sd, - BSON_ARRAY(BSON_ARRAY(5 << 10) - << BSON_ARRAY(6 << 8) << BSON_ARRAY("MISSING") << BSON_ARRAY(1 << 9 << 10))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggStdDev"_sd, - BSON_ARRAY(BSON_ARRAY(5 << 10) - << BSON_ARRAY(5 << 10 << 6 << 8) << BSON_ARRAY(5 << 10 << 6 << 8) - << BSON_ARRAY(5 << 10 << 6 << 8 << 1 << 9 << 10))); - - auto accStatement = makeAccumulationStatement("$stdDevPop"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); - - // Feed the result back into the input accessor. - auto [resTag, resVal] = _aggAccessor.copyOrMoveValue(); - _inputAccessor.reset(true, resTag, resVal); - auto finalizeExpr = - stage_builder::makeFunction("stdDevPopFinalize", stage_builder::makeVariable(_inputSlotId)); - auto finalizeCode = compileExpression(*finalizeExpr); - auto [finalizedTag, finalizedRes] = runCompiledExpression(finalizeCode.get()); - ASSERT_EQ(finalizedTag, sbe::value::TypeTags::NumberDouble); - ASSERT_APPROX_EQUAL(sbe::value::bitcastTo<double>(finalizedRes), 3.0237, 0.0001); -} - -TEST_F(SbeStageBuilderGroupAggCombinerTest, CombinePartialAggsStdDevSamp) { - auto [inputTag, inputVal] = makePartialAggArray( - "aggStdDev"_sd, - BSON_ARRAY(BSON_ARRAY(5 << 10) - << BSON_ARRAY(6 << 8) << BSON_ARRAY("MISSING") << BSON_ARRAY(1 << 9 << 10))); - auto [expectedTag, expectedVal] = makePartialAggArray( - "aggStdDev"_sd, - BSON_ARRAY(BSON_ARRAY(5 << 10) - << BSON_ARRAY(5 << 10 << 6 << 8) << BSON_ARRAY(5 << 10 << 6 << 8) - << BSON_ARRAY(5 << 10 << 6 << 8 << 1 << 9 << 10))); - - auto accStatement = makeAccumulationStatement("$stdDevSamp"_sd); - auto compiledExpr = compileSingleInputNoCollator(accStatement); - aggregateAndAssertResults(inputTag, inputVal, expectedTag, expectedVal, compiledExpr.get()); - - // Feed the result back into the input accessor. - auto [resTag, resVal] = _aggAccessor.copyOrMoveValue(); - _inputAccessor.reset(true, resTag, resVal); - auto finalizeExpr = stage_builder::makeFunction("stdDevSampFinalize", - stage_builder::makeVariable(_inputSlotId)); - auto finalizeCode = compileExpression(*finalizeExpr); - auto [finalizedTag, finalizedRes] = runCompiledExpression(finalizeCode.get()); - ASSERT_EQ(finalizedTag, sbe::value::TypeTags::NumberDouble); - ASSERT_APPROX_EQUAL(sbe::value::bitcastTo<double>(finalizedRes), 3.2660, 0.0001); -} - } // namespace mongo diff --git a/src/mongo/db/query/sbe_stage_builder_expression.cpp b/src/mongo/db/query/sbe_stage_builder_expression.cpp index 8ecc4961435..9fd4aba048e 100644 --- a/src/mongo/db/query/sbe_stage_builder_expression.cpp +++ b/src/mongo/db/query/sbe_stage_builder_expression.cpp @@ -27,12 +27,16 @@ * it in the license file. */ +#include "mongo/platform/basic.h" + #include "mongo/db/query/sbe_stage_builder_expression.h" +#include "mongo/db/query/util/make_data_structure.h" #include "mongo/base/string_data.h" #include "mongo/db/exec/sbe/stages/branch.h" #include "mongo/db/exec/sbe/stages/co_scan.h" #include "mongo/db/exec/sbe/stages/filter.h" +#include "mongo/db/exec/sbe/stages/hash_agg.h" #include "mongo/db/exec/sbe/stages/limit_skip.h" #include "mongo/db/exec/sbe/stages/loop_join.h" #include "mongo/db/exec/sbe/stages/project.h" @@ -48,7 +52,6 @@ #include "mongo/db/query/projection_parser.h" #include "mongo/db/query/sbe_stage_builder.h" #include "mongo/db/query/sbe_stage_builder_eval_frame.h" -#include "mongo/db/query/util/make_data_structure.h" #include "mongo/util/str.h" #include <absl/container/flat_hash_map.h> @@ -477,7 +480,6 @@ public: void visit(const ExpressionSetField* expr) final {} void visit(const ExpressionTsSecond* expr) final {} void visit(const ExpressionTsIncrement* expr) final {} - void visit(const ExpressionInternalKeyStringValue* expr) final {} private: void visitMultiBranchLogicExpression(const Expression* expr, sbe::EPrimBinary::Op logicOp) { @@ -711,7 +713,6 @@ public: void visit(const ExpressionSetField* expr) final {} void visit(const ExpressionTsSecond* expr) final {} void visit(const ExpressionTsIncrement* expr) final {} - void visit(const ExpressionInternalKeyStringValue* expr) final {} private: void visitMultiBranchLogicExpression(const Expression* expr, sbe::EPrimBinary::Op logicOp) { @@ -734,9 +735,6 @@ struct DoubleBound { static DoubleBound plusInfinity() { return DoubleBound(std::numeric_limits<double>::infinity(), false); } - static DoubleBound plusInfinityInclusive() { - return DoubleBound(std::numeric_limits<double>::infinity(), true); - } std::string printLowerBound() const { return str::stream() << (inclusive ? "[" : "(") << bound; } @@ -1183,46 +1181,103 @@ public: return; } - auto binds = sbe::makeEs(); - for (size_t i = 0; i < numChildren; ++i) { - binds.emplace_back(_context->popExpr()); + sbe::EExpression::Vector nullChecks; + std::vector<EvalStage> unionBranches; + std::vector<sbe::value::SlotVector> unionInputSlots; + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> projections; + + nullChecks.reserve(numChildren); + unionBranches.reserve(numChildren); + unionInputSlots.reserve(numChildren); + for (size_t idx = 0; idx < numChildren; ++idx) { + auto outputSlot = _context->state.slotId(); + projections.emplace(outputSlot, _context->popExpr()); + unionBranches.emplace_back( + EvalStage{makeLimitCoScanTree(_context->planNodeId), sbe::makeSV()}); + unionInputSlots.emplace_back(sbe::makeSV(outputSlot)); + nullChecks.emplace_back(generateNullOrMissing(outputSlot)); } - std::reverse(binds.begin(), binds.end()); - auto frameId = _context->state.frameId(); - auto args = sbe::makeEs(); + // Build a project to capture our child expressions. + std::reverse(std::begin(unionInputSlots), std::end(unionInputSlots)); + auto project = makeProject( + _context->extractCurrentEvalStage(), std::move(projections), _context->planNodeId); - std::unique_ptr<sbe::EExpression> checkArgsForNull; - for (size_t i = 0; i < numChildren; ++i) { - sbe::EVariable argRef(frameId, i); - args.emplace_back(argRef.clone()); + // Build a union stage to consolidate array input branches into a stream. + auto unionOutputSlot = _context->state.slotId(); + auto unionStage = makeUnion(std::move(unionBranches), + std::move(unionInputSlots), + sbe::makeSV(unionOutputSlot), + _context->planNodeId); - checkArgsForNull = checkArgsForNull ? makeBinaryOp(sbe::EPrimBinary::logicOr, - std::move(checkArgsForNull), - generateNullOrMissing(argRef)) - : generateNullOrMissing(argRef); - } + auto collatorSlot = _context->state.data->env->getSlotIfExists("collator"_sd); - auto nullOrFailExpr = - sbe::makeE<sbe::EIf>(std::move(checkArgsForNull), - makeConstant(sbe::value::TypeTags::Null, 0), - sbe::makeE<sbe::EFail>(ErrorCodes::Error{5153400}, - "$concatArrays only supports arrays")); + // Build a filter that will throw an 'EFail' if any element coming from the union is NOT + // an array. + auto filter = makeFilter<false, false>( + std::move(unionStage), + makeBinaryOp(sbe::EPrimBinary::logicOr, + makeFunction("isArray", makeVariable(unionOutputSlot)), + sbe::makeE<sbe::EFail>(ErrorCodes::Error{5153400}, + "$concatArrays only supports arrays")), + _context->planNodeId); - auto resultExpr = makeLocalBind( - _context->state.frameIdGenerator, - [&](sbe::EVariable concatArraysRef) { - // We optimize for the case where all of the args are arrays. If concatArrays() - // returns Nothing, then we deal with checking if any of the args are null and - // either returning null or raising an error. - return sbe::makeE<sbe::EIf>(makeFunction("exists", concatArraysRef.clone()), - concatArraysRef.clone(), - std::move(nullOrFailExpr)); - }, - sbe::makeE<sbe::EFunction>("concatArrays"_sd, std::move(args))); + // Build subtree to handle nulls. If an input is null, return null. Otherwise, unwind the + // input and concatenate it into an array using addToArray. + auto unwindEvalStage = + makeUnwind(std::move(filter), _context->state.slotIdGenerator, _context->planNodeId); + auto unwindSlot = unwindEvalStage.outSlots.front(); + + // Create a group stage to append all streamed elements into one array. This is the final + // output when the input consists entirely of arrays. + auto finalAddToArrayExpr = makeFunction("addToArray", makeVariable(unwindSlot)); + auto finalGroupSlot = _context->state.slotId(); + auto finalGroupStage = + makeHashAgg(std::move(unwindEvalStage), + sbe::makeSV(), + sbe::makeEM(finalGroupSlot, std::move(finalAddToArrayExpr)), + collatorSlot, + _context->state.allowDiskUse, + _context->planNodeId); + + // Returns true if any of our input expressions return null. + using iter_t = sbe::EExpression::Vector::iterator; + auto checkPartsForNull = std::accumulate( + std::move_iterator<iter_t>(nullChecks.begin() + 1), + std::move_iterator<iter_t>(nullChecks.end()), + std::move(nullChecks.front()), + [](auto&& acc, auto&& b) { + return makeBinaryOp(sbe::EPrimBinary::logicOr, std::move(acc), std::move(b)); + }); - _context->pushExpr( - sbe::makeE<sbe::ELocalBind>(frameId, std::move(binds), std::move(resultExpr))); + // Create a branch stage to select between the branch that produces one null if any elements + // in the original input were null or missing, or otherwise select the branch that unwinds + // and concatenates elements into the output array. + auto [nullSlot, nullStage] = [&] { + auto outputSlot = _context->state.slotId(); + auto nullEvalStage = + makeProject({makeLimitCoScanTree(_context->planNodeId), sbe::makeSV()}, + _context->planNodeId, + outputSlot, + makeConstant(sbe::value::TypeTags::Null, 0)); + return std::make_pair(outputSlot, std::move(nullEvalStage)); + }(); + + auto branchSlot = _context->state.slotId(); + auto branchNullEvalStage = makeBranch(std::move(nullStage), + std::move(finalGroupStage), + std::move(checkPartsForNull), + sbe::makeSV(nullSlot), + sbe::makeSV(finalGroupSlot), + sbe::makeSV(branchSlot), + _context->planNodeId); + + // Create nlj to connect outer project with inner branch that handles null input. + _context->pushExpr(branchSlot, + makeLoopJoin(std::move(project), + std::move(branchNullEvalStage), + _context->planNodeId, + _context->getLexicalEnvironment())); } void visit(const ExpressionCond* expr) final { visitConditionalExpression(expr); @@ -2122,52 +2177,12 @@ public: std::vector<EvalExprStagePair> branches; branches.reserve(numChildren); - auto childStageCount = 0; for (size_t i = 0; i < numChildren; ++i) { auto [expr, stage] = _context->popFrame(); - if (stage.stage.get() != nullptr) { - childStageCount++; - } branches.emplace_back(std::move(expr), std::move(stage)); } std::reverse(branches.begin(), branches.end()); - // If there is no separate child stage branch, then we can implement $ifNull as a simple - // projection of SBE if expression, instead of with union stages. - if (childStageCount == 0) { - auto stage = _context->extractCurrentEvalStage(); - - std::vector<sbe::value::SlotId> slots; - slots.reserve(branches.size()); - sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> projects; - for (auto& branch : branches) { - if (branch.first.getSlot()) { - slots.push_back(*branch.first.getSlot()); - } else { - auto slot = _context->state.slotId(); - slots.push_back(slot); - projects.emplace(slot, branch.first.extractExpr()); - } - } - if (!projects.empty()) { - stage = makeProject(std::move(stage), std::move(projects), _context->planNodeId); - } - - auto expr = sbe::makeE<sbe::EVariable>(slots[slots.size() - 1]); - for (int i = slots.size() - 2; i >= 0; i--) { - auto thenExpr = sbe::makeE<sbe::EVariable>(slots[i]); - auto condExpr = makeNot(generateNullOrMissing(thenExpr->clone())); - expr = - sbe::makeE<sbe::EIf>(std::move(condExpr), std::move(thenExpr), std::move(expr)); - } - - auto outSlot = _context->state.slotId(); - stage = makeProject(std::move(stage), _context->planNodeId, outSlot, std::move(expr)); - - _context->pushExpr(outSlot, std::move(stage)); - return; - } - // Prepare to create limit-1/union with N branches (where N is the number of operands). Each // branch will be evaluated from left to right until one of the branches produces a value. auto branchFn = [](EvalExpr evalExpr, @@ -2450,7 +2465,13 @@ public: exprs[--i] = makeConstant(rit->first); } - _context->pushExpr(sbe::makeE<sbe::EFunction>("newObj"_sd, std::move(exprs))); + auto fieldSlot{_context->state.slotIdGenerator->generate()}; + auto stage = makeProject(_context->extractCurrentEvalStage(), + _context->planNodeId, + fieldSlot, + sbe::makeE<sbe::EFunction>("newObj"_sd, std::move(exprs))); + + _context->pushExpr(fieldSlot, std::move(stage)); } void visit(const ExpressionOr* expr) final { visitMultiBranchLogicExpression(expr, sbe::EPrimBinary::logicOr); @@ -2889,7 +2910,7 @@ public: } void visit(const ExpressionHyperbolicArcCosine* expr) final { generateTrigonometricExpressionWithBounds( - "acosh", DoubleBound(1.0, true), DoubleBound::plusInfinityInclusive()); + "acosh", DoubleBound(1.0, true), DoubleBound::plusInfinity()); } void visit(const ExpressionHyperbolicArcSine* expr) final { generateTrigonometricExpression("asinh"); @@ -3072,10 +3093,6 @@ public: _context->pushExpr(std::move(tsIncrementExpr)); } - void visit(const ExpressionInternalKeyStringValue* expr) final { - unsupportedExpression(expr->getOpName()); - } - private: /** * Shared logic for $and, $or. Converts each child into an EExpression that evaluates to Boolean @@ -3336,8 +3353,7 @@ private: */ void generateTrigonometricExpressionBinary(StringData exprName) { _context->ensureArity(2); - auto x = _context->popExpr(); - auto y = _context->popExpr(); + auto genericTrignomentricExpr = makeLocalBind( _context->state.frameIdGenerator, [&](sbe::EVariable lhs, sbe::EVariable rhs) { @@ -3356,8 +3372,8 @@ private: str::stream() << "$" << exprName << " supports only numeric types")); }, - std::move(y), - std::move(x)); + _context->popExpr(), + _context->popExpr()); _context->pushExpr(std::move(genericTrignomentricExpr)); } @@ -3398,17 +3414,13 @@ private: str::stream() << "$" << exprName.toString() << " supports only numeric types"), sbe::makeE<sbe::EIf>( - // return NaN when NaN is the input. - generateNaNCheck(inputRef), - inputRef.clone(), - sbe::makeE<sbe::EIf>( - std::move(checkBounds), - makeFunction(exprName.toString(), inputRef.clone()), - sbe::makeE<sbe::EFail>( - ErrorCodes::Error{4995503}, - str::stream() << "Cannot apply $" << exprName.toString() - << ", value must be in " << lowerBound.printLowerBound() - << ", " << upperBound.printUpperBound()))))); + std::move(checkBounds), + makeFunction(exprName.toString(), inputRef.clone()), + sbe::makeE<sbe::EFail>(ErrorCodes::Error{4995503}, + str::stream() << "Cannot apply $" << exprName.toString() + << ", value must be in " + << lowerBound.printLowerBound() << ", " + << upperBound.printUpperBound())))); _context->pushExpr(sbe::makeE<sbe::ELocalBind>( frameId, std::move(binds), std::move(genericTrignomentricExpr))); diff --git a/src/mongo/db/query/sbe_stage_builder_helpers.cpp b/src/mongo/db/query/sbe_stage_builder_helpers.cpp index 3307a6d7597..c36947a23ad 100644 --- a/src/mongo/db/query/sbe_stage_builder_helpers.cpp +++ b/src/mongo/db/query/sbe_stage_builder_helpers.cpp @@ -36,8 +36,6 @@ #include <iterator> #include <numeric> -#include "mongo/db/catalog/health_log_gen.h" -#include "mongo/db/catalog/health_log_interface.h" #include "mongo/db/exec/sbe/expressions/expression.h" #include "mongo/db/exec/sbe/stages/branch.h" #include "mongo/db/exec/sbe/stages/co_scan.h" @@ -55,7 +53,6 @@ #include "mongo/db/query/sbe_stage_builder.h" #include "mongo/db/storage/execution_context.h" #include "mongo/logv2/log.h" -#include "mongo/util/stacktrace.h" namespace mongo::stage_builder { @@ -473,22 +470,14 @@ EvalStage makeUnion(std::vector<EvalStage> inputStages, EvalStage makeHashAgg(EvalStage stage, sbe::value::SlotVector gbs, - sbe::SlotExprPairVector aggs, + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> aggs, boost::optional<sbe::value::SlotId> collatorSlot, bool allowDiskUse, - sbe::SlotExprPairVector mergingExprs, PlanNodeId planNodeId) { stage.outSlots = gbs; for (auto& [slot, _] : aggs) { stage.outSlots.push_back(slot); } - - // In debug builds or when we explicitly set the query knob, we artificially force frequent - // spilling. This makes sure that our tests exercise the spilling algorithm and the associated - // logic for merging partial aggregates which otherwise would require large data sizes to - // exercise. - const bool forceIncreasedSpilling = allowDiskUse && - (kDebugBuild || internalQuerySlotBasedExecutionHashAggForceIncreasedSpilling.load()); stage.stage = sbe::makeS<sbe::HashAggStage>(std::move(stage.stage), std::move(gbs), std::move(aggs), @@ -496,9 +485,7 @@ EvalStage makeHashAgg(EvalStage stage, true /* optimized close */, collatorSlot, allowDiskUse, - std::move(mergingExprs), - planNodeId, - forceIncreasedSpilling); + planNodeId); return stage; } @@ -862,22 +849,6 @@ void indexKeyCorruptionCheckCallback(OperationContext* opCtx, auto bsonKeyString = KeyString::toBson(*keyString, Ordering::make(bsonKeyPattern)); auto hydratedKey = IndexKeyEntry::rehydrateKey(bsonKeyPattern, bsonKeyString); - HealthLogEntry entry; - entry.setNss(nss); - 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", rid.toString()); - bob.append("indexKeyData", hydratedKey); - bob.appendElements(getStackTrace().getBSONRepresentation()); - entry.setData(bob.obj()); - - HealthLogInterface::get(opCtx)->log(entry); - LOGV2_ERROR_OPTIONS( 5113709, {logv2::UserAssertAfterLog(ErrorCodes::DataCorruptionDetected)}, @@ -897,13 +868,12 @@ void indexKeyCorruptionCheckCallback(OperationContext* opCtx, * or that the index keys are still part of the underlying index. */ bool indexKeyConsistencyCheckCallback(OperationContext* opCtx, - StringMap<const IndexCatalogEntry*>& entryMap, + StringMap<const IndexAccessMethod*> iamTable, sbe::value::SlotAccessor* snapshotIdAccessor, sbe::value::SlotAccessor* indexIdAccessor, sbe::value::SlotAccessor* indexKeyAccessor, const CollectionPtr& collection, const Record& nextRecord) { - // The index consistency check is only performed when 'snapshotIdAccessor' is set. if (snapshotIdAccessor) { auto currentSnapshotId = opCtx->recoveryUnit()->getSnapshotId(); auto [snapshotIdTag, snapshotIdVal] = snapshotIdAccessor->getViewOfValue(); @@ -934,29 +904,14 @@ bool indexKeyConsistencyCheckCallback(OperationContext* opCtx, auto indexId = sbe::value::getStringView(indexIdTag, indexIdVal); tassert(5290712, "KeyString does not exist", keyString); - auto it = entryMap.find(indexId); - - // If 'entryMap' doesn't contain an entry for 'indexId', create one. - if (it == entryMap.end()) { - auto indexCatalog = collection->getIndexCatalog(); - auto indexDesc = indexCatalog->findIndexByName(opCtx, indexId); - auto entry = indexDesc ? indexDesc->getEntry() : nullptr; + auto it = iamTable.find(indexId); + tassert(5290713, + str::stream() << "IndexAccessMethod not found for index " << indexId, + it != iamTable.end()); - // Throw an error if we can't get the IndexDescriptor or the IndexCatalogEntry - // (or if the index is dropped). - uassert(ErrorCodes::QueryPlanKilled, - str::stream() << "query plan killed :: index dropped: " << indexId, - indexDesc && entry && !entry->isDropped()); - - auto [newIt, _] = entryMap.emplace(indexId, entry); - - it = newIt; - } - - auto entry = it->second; - auto iam = entry->accessMethod()->asSortedData(); + auto iam = it->second->asSortedData(); tassert(5290709, - str::stream() << "Expected to find SortedDataIndexAccessMethod for index: " + str::stream() << "Expected to find SortedDataIndexAccessMethod for index " << indexId, iam); @@ -984,7 +939,6 @@ bool indexKeyConsistencyCheckCallback(OperationContext* opCtx, return keys->count(*keyString); } } - return true; } @@ -996,6 +950,7 @@ makeLoopJoinForFetch(std::unique_ptr<sbe::PlanStage> inputStage, sbe::value::SlotId indexKeySlot, sbe::value::SlotId indexKeyPatternSlot, const CollectionPtr& collToFetch, + StringMap<const IndexAccessMethod*> iamMap, PlanNodeId planNodeId, sbe::value::SlotVector slotsToForward, sbe::value::SlotIdGenerator& slotIdGenerator) { @@ -1007,7 +962,10 @@ makeLoopJoinForFetch(std::unique_ptr<sbe::PlanStage> inputStage, auto resultSlot = slotIdGenerator.generate(); auto recordIdSlot = slotIdGenerator.generate(); - sbe::ScanCallbacks callbacks(indexKeyCorruptionCheckCallback, indexKeyConsistencyCheckCallback); + using namespace std::placeholders; + sbe::ScanCallbacks callbacks( + indexKeyCorruptionCheckCallback, + std::bind(indexKeyConsistencyCheckCallback, _1, std::move(iamMap), _2, _3, _4, _5, _6)); // Scan the collection in the range [seekKeySlot, Inf). auto scanStage = sbe::makeS<sbe::ScanStage>(collToFetch->uuid(), diff --git a/src/mongo/db/query/sbe_stage_builder_helpers.h b/src/mongo/db/query/sbe_stage_builder_helpers.h index e2e203bdd55..05cf73896e0 100644 --- a/src/mongo/db/query/sbe_stage_builder_helpers.h +++ b/src/mongo/db/query/sbe_stage_builder_helpers.h @@ -36,7 +36,6 @@ #include "mongo/db/exec/sbe/expressions/expression.h" #include "mongo/db/exec/sbe/stages/filter.h" -#include "mongo/db/exec/sbe/stages/hash_agg.h" #include "mongo/db/exec/sbe/stages/makeobj.h" #include "mongo/db/exec/sbe/stages/project.h" #include "mongo/db/pipeline/expression.h" @@ -417,10 +416,9 @@ EvalStage makeUnion(std::vector<EvalStage> inputStages, EvalStage makeHashAgg(EvalStage stage, sbe::value::SlotVector gbs, - sbe::SlotExprPairVector aggs, + sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> aggs, boost::optional<sbe::value::SlotId> collatorSlot, bool allowDiskUse, - sbe::SlotExprPairVector mergingExprs, PlanNodeId planNodeId); EvalStage makeMkBsonObj(EvalStage stage, @@ -539,6 +537,7 @@ makeLoopJoinForFetch(std::unique_ptr<sbe::PlanStage> inputStage, sbe::value::SlotId indexKeySlot, sbe::value::SlotId indexKeyPatternSlot, const CollectionPtr& collToFetch, + StringMap<const IndexAccessMethod*> iamMap, PlanNodeId planNodeId, sbe::value::SlotVector slotsToForward, sbe::value::SlotIdGenerator& slotIdGenerator); diff --git a/src/mongo/db/query/sbe_stage_builder_index_scan.cpp b/src/mongo/db/query/sbe_stage_builder_index_scan.cpp index cc63eee572a..7112e8ad56b 100644 --- a/src/mongo/db/query/sbe_stage_builder_index_scan.cpp +++ b/src/mongo/db/query/sbe_stage_builder_index_scan.cpp @@ -283,6 +283,10 @@ generateOptimizedMultiIntervalIndexScan(StageBuilderState& state, makeFunction("getField"_sd, makeVariable(unwindSlot), makeConstant("l"_sd))); projects.emplace(highKeySlot, makeFunction("getField"_sd, makeVariable(unwindSlot), makeConstant("h"_sd))); + if (indexIdSlot) { + // Construct a copy of 'indexName' to project for use in the index consistency check. + projects.emplace(*indexIdSlot, makeConstant(indexName)); + } if (indexKeyPatternSlot) { auto [bsonObjTag, bsonObjVal] = @@ -296,13 +300,20 @@ generateOptimizedMultiIntervalIndexScan(StageBuilderState& state, auto project = sbe::makeS<sbe::ProjectStage>(std::move(unwind), std::move(projects), planNodeId); + // Whereas 'snapshotIdSlot' is used by the caller to inspect the snapshot id of the latest index + // key, 'indexSnapshotSlot' is updated by the IndexScan below during yield to obtain the latest + // snapshot id. + boost::optional<sbe::value::SlotId> indexSnapshotSlot; + if (snapshotIdSlot) { + indexSnapshotSlot = slotIdGenerator->generate(); + } + auto stage = sbe::makeS<sbe::IndexScanStage>(collection->uuid(), indexName, forward, recordSlot, recordIdSlot, - snapshotIdSlot, - indexIdSlot, + indexSnapshotSlot, indexKeysToInclude, std::move(indexKeySlots), lowKeySlot, @@ -310,7 +321,19 @@ generateOptimizedMultiIntervalIndexScan(StageBuilderState& state, yieldPolicy, planNodeId); + // Add a project on top of the index scan to remember the snapshotId of the most recent index + // key returned by the IndexScan above. Otherwise, the index key's snapshot id would be + // overwritten during yield. + if (snapshotIdSlot) { + stage = sbe::makeProjectStage( + std::move(stage), planNodeId, *snapshotIdSlot, makeVariable(*indexSnapshotSlot)); + } + auto outerSv = sbe::makeSV(); + if (indexIdSlot) { + outerSv.push_back(*indexIdSlot); + } + if (indexKeyPatternSlot) { outerSv.push_back(*indexKeyPatternSlot); } @@ -402,6 +425,10 @@ makeRecursiveBranchForGenericIndexScan(const CollectionPtr& collection, // contain a value from the stack spool. See below for details. sbe::value::SlotMap<std::unique_ptr<sbe::EExpression>> projects; projects.emplace(lowKeySlot, makeVariable(seekKeySlot)); + if (indexIdSlot) { + // Construct a copy of 'indexName' to project for use in the index consistency check. + projects.emplace(*indexIdSlot, makeConstant(indexName)); + } if (indexKeyPatternSlot) { auto [bsonObjTag, bsonObjVal] = sbe::value::copyValue( @@ -422,7 +449,6 @@ makeRecursiveBranchForGenericIndexScan(const CollectionPtr& collection, resultSlot, recordIdSlot, snapshotIdSlot, - indexIdSlot, indexKeysToInclude, std::move(savedIndexKeySlots), lowKeySlot, @@ -432,6 +458,10 @@ makeRecursiveBranchForGenericIndexScan(const CollectionPtr& collection, // Get the low key from the outer side and feed it to the inner side (ixscan). sbe::value::SlotVector outerSv = sbe::makeSV(); + if (indexIdSlot) { + outerSv.push_back(*indexIdSlot); + } + if (indexKeyPatternSlot) { outerSv.push_back(*indexKeyPatternSlot); } @@ -444,11 +474,19 @@ makeRecursiveBranchForGenericIndexScan(const CollectionPtr& collection, planNodeId); sbe::value::SlotVector correlatedSv = sbe::makeSV(seekKeySlot); + if (indexIdSlot) { + correlatedSv.push_back(*indexIdSlot); + } + if (indexKeyPatternSlot) { correlatedSv.push_back(*indexKeyPatternSlot); } auto spoolValsSV = sbe::makeSV(seekKeySlot); + if (indexIdSlot) { + spoolValsSV.push_back(*indexIdSlot); + } + if (indexKeyPatternSlot) { spoolValsSV.push_back(*indexKeyPatternSlot); } @@ -806,6 +844,11 @@ generateSingleIntervalIndexScan(StageBuilderState& state, auto lowKeySlot = makeKeySlot(std::move(lowKey)); auto highKeySlot = makeKeySlot(std::move(highKey)); + if (indexIdSlot) { + // Construct a copy of 'indexName' to project for use in the index consistency check. + projects.emplace(*indexIdSlot, makeConstant(indexName)); + } + if (indexKeyPatternSlot) { auto [bsonObjTag, bsonObjVal] = sbe::value::copyValue(sbe::value::TypeTags::bsonObject, @@ -840,6 +883,14 @@ generateSingleIntervalIndexScan(StageBuilderState& state, planNodeId); }(); + // Whereas 'snapshotIdSlot' is used by the caller to inspect the snapshot id of the latest index + // key, 'indexSnapshotSlot' is updated by the IndexScan below during yield to obtain the latest + // snapshot id. + boost::optional<sbe::value::SlotId> indexSnapshotSlot; + if (snapshotIdSlot) { + indexSnapshotSlot = slotIdGenerator->generate(); + } + // Scan the index in the range {'lowKeySlot', 'highKeySlot'} (subject to inclusive or // exclusive boundaries), and produce a single field recordIdSlot that can be used to // position into the collection. @@ -848,8 +899,7 @@ generateSingleIntervalIndexScan(StageBuilderState& state, forward, recordSlot, recordIdSlot, - snapshotIdSlot, - indexIdSlot, + indexSnapshotSlot, indexKeysToInclude, std::move(indexKeySlots), lowKeySlot, @@ -857,7 +907,19 @@ generateSingleIntervalIndexScan(StageBuilderState& state, yieldPolicy, planNodeId); + // Add a project on top of the index scan to remember the snapshotId of the most recent index + // key returned by the IndexScan above. Otherwise, the index key's snapshot id would be + // overwritten during yield. + if (snapshotIdSlot) { + stage = sbe::makeProjectStage( + std::move(stage), planNodeId, *snapshotIdSlot, makeVariable(*indexSnapshotSlot)); + } + auto outerSv = sbe::makeSV(); + if (indexIdSlot) { + outerSv.push_back(*indexIdSlot); + } + if (indexKeyPatternSlot) { outerSv.push_back(*indexKeyPatternSlot); } @@ -880,7 +942,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScan( const IndexScanNode* ixn, const sbe::IndexKeysInclusionSet& originalIndexKeyBitset, PlanYieldPolicy* yieldPolicy, - bool doIndexConsistencyCheck, + StringMap<const IndexAccessMethod*>* iamMap, bool needsCorruptionCheck) { auto indexName = ixn->index.identifier.catalogName; @@ -918,12 +980,15 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScan( auto indexKeySlots = state.slotIdGenerator->generateMultiple(indexKeyBitset.count()); sbe::value::SlotVector relevantSlots; - // Generate the relevant slots. + // Generate the relevant slots and add the access method corresponding to 'indexName' to + // 'iamMap' if a parent stage needs to execute a consistency check. boost::optional<sbe::value::SlotId> snapshotIdSlot; boost::optional<sbe::value::SlotId> indexIdSlot; boost::optional<sbe::value::SlotId> indexKeySlot; - if (doIndexConsistencyCheck) { + if (iamMap) { + iamMap->insert({indexName, accessMethod}); + snapshotIdSlot = state.slotId(); outputs.set(PlanStageSlots::kSnapshotId, *snapshotIdSlot); relevantSlots.push_back(*snapshotIdSlot); @@ -1123,7 +1188,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScanWith const IndexScanNode* ixn, const sbe::IndexKeysInclusionSet& originalIndexKeyBitset, PlanYieldPolicy* yieldPolicy, - bool doIndexConsistencyCheck, + StringMap<const IndexAccessMethod*>* iamMap, bool needsCorruptionCheck) { const bool forward = ixn->direction == 1; auto indexName = ixn->index.identifier.catalogName; @@ -1137,6 +1202,11 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScanWith // Find the IndexAccessMethod which corresponds to the 'indexName'. auto accessMethod = descriptor->getEntry()->accessMethod()->asSortedData(); + // Add the access method corresponding to 'indexName' to the 'iamMap' if a parent stage needs to + // execute a consistency check. + if (iamMap) { + iamMap->insert({indexName, accessMethod}); + } PlanStageSlots outputs; sbe::value::SlotVector relevantSlots; std::unique_ptr<sbe::PlanStage> stage; @@ -1181,9 +1251,9 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScanWith nullptr, indexKeyBitset, outputIndexKeySlots, - makeSlot(doIndexConsistencyCheck, PlanStageSlots::kSnapshotId), - makeSlot(doIndexConsistencyCheck, PlanStageSlots::kIndexId), - makeSlot(doIndexConsistencyCheck, PlanStageSlots::kIndexKey), + makeSlot(iamMap, PlanStageSlots::kSnapshotId), + makeSlot(iamMap, PlanStageSlots::kIndexId), + makeSlot(iamMap, PlanStageSlots::kIndexKey), makeSlot(needsCorruptionCheck, PlanStageSlots::kIndexKeyPattern), yieldPolicy, ixn->nodeId()); @@ -1221,11 +1291,11 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScanWith }; auto [genericIndexScanSnapshotIdSlot, optimizedIndexScanSnapshotIdSlot] = - makeSlotsForThenElseBranches(doIndexConsistencyCheck, PlanStageSlots::kSnapshotId); + makeSlotsForThenElseBranches(iamMap, PlanStageSlots::kSnapshotId); auto [genericIndexScanIndexIdSlot, optimizedIndexScanIndexIdSlot] = - makeSlotsForThenElseBranches(doIndexConsistencyCheck, PlanStageSlots::kIndexId); + makeSlotsForThenElseBranches(iamMap, PlanStageSlots::kIndexId); auto [genericIndexScanIndexKeySlot, optimizedIndexScanIndexKeySlot] = - makeSlotsForThenElseBranches(doIndexConsistencyCheck, PlanStageSlots::kIndexKey); + makeSlotsForThenElseBranches(iamMap, PlanStageSlots::kIndexKey); // Generate a slot for an index key pattern if a parent stage needs to execute a // corruption check. diff --git a/src/mongo/db/query/sbe_stage_builder_index_scan.h b/src/mongo/db/query/sbe_stage_builder_index_scan.h index 08e239c018a..340a03051eb 100644 --- a/src/mongo/db/query/sbe_stage_builder_index_scan.h +++ b/src/mongo/db/query/sbe_stage_builder_index_scan.h @@ -63,7 +63,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScan( const IndexScanNode* ixn, const sbe::IndexKeysInclusionSet& indexKeyBitset, PlanYieldPolicy* yieldPolicy, - bool doIndexConsistencyCheck, + StringMap<const IndexAccessMethod*>* iamMap, bool needsCorruptionCheck); /** @@ -164,6 +164,6 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> generateIndexScanWith const IndexScanNode* ixn, const sbe::IndexKeysInclusionSet& indexKeyBitset, PlanYieldPolicy* yieldPolicy, - bool doIndexConsistencyCheck, + StringMap<const IndexAccessMethod*>* iamMap, bool needsCorruptionCheck); } // namespace mongo::stage_builder diff --git a/src/mongo/db/query/sbe_stage_builder_lookup.cpp b/src/mongo/db/query/sbe_stage_builder_lookup.cpp index 6037fb4eef7..4b62228edde 100644 --- a/src/mongo/db/query/sbe_stage_builder_lookup.cpp +++ b/src/mongo/db/query/sbe_stage_builder_lookup.cpp @@ -342,15 +342,12 @@ std::pair<SlotId /* keyValuesSetSlot */, std::unique_ptr<sbe::PlanStage>> buildK // Re-pack the individual key values into a set. We don't cap "addToSet" here because its size // is bounded by the size of the record. SlotId keyValuesSetSlot = slotIdGenerator.generate(); - SlotId spillSlot = slotIdGenerator.generate(); EvalStage packedKeyValuesStage = makeHashAgg( EvalStage{std::move(keyValuesStage), SlotVector{}}, makeSV(), /* groupBy slots - "none" means creating a single group */ - makeSlotExprPairVec(keyValuesSetSlot, - makeFunction("addToSet"_sd, makeVariable(keyValueSlot))), + makeEM(keyValuesSetSlot, makeFunction("addToSet"_sd, makeVariable(keyValueSlot))), boost::none /* we group _all_ key values into a single set, so collator is irrelevant */, allowDiskUse, - makeSlotExprPairVec(spillSlot, makeFunction("aggSetUnion"_sd, makeVariable(spillSlot))), nodeId); // The set in 'keyValuesSetSlot' might end up empty if the localField contained only missing and @@ -406,20 +403,15 @@ std::pair<SlotId /* resultSlot */, std::unique_ptr<sbe::PlanStage>> buildForeign // are no matches, return an empty array. const int sizeCap = internalLookupStageIntermediateDocumentMaxSizeBytes.load(); SlotId accumulatorSlot = slotIdGenerator.generate(); - SlotId spillSlot = slotIdGenerator.generate(); innerBranch = makeHashAgg( std::move(innerBranch), makeSV(), /* groupBy slots */ - makeSlotExprPairVec(accumulatorSlot, - makeFunction("addToArrayCapped"_sd, - makeVariable(foreignRecordSlot), - makeConstant(TypeTags::NumberInt32, sizeCap))), + makeEM(accumulatorSlot, + makeFunction("addToArrayCapped"_sd, + makeVariable(foreignRecordSlot), + makeConstant(TypeTags::NumberInt32, sizeCap))), {} /* collatorSlot, no collation here because we want to return all matches "as is" */, allowDiskUse, - makeSlotExprPairVec(spillSlot, - makeFunction("aggConcatArraysCapped", - makeVariable(spillSlot), - makeConstant(TypeTags::NumberInt32, sizeCap))), nodeId); // 'accumulatorSlot' is either Nothing or contains an array of size two, where the front element @@ -618,6 +610,7 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( const FieldPath& foreignFieldName, const CollectionPtr& foreignColl, const IndexEntry& index, + StringMap<const IndexAccessMethod*>& iamMap, PlanYieldPolicySBE* yieldPolicy, boost::optional<SlotId> collatorSlot, const PlanNodeId nodeId, @@ -636,6 +629,7 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( foreignColl->getIndexCatalog()->getEntry(indexDescriptor)->accessMethod()->asSortedData(); const auto indexVersion = indexAccessMethod->getSortedDataInterface()->getKeyStringVersion(); const auto indexOrdering = indexAccessMethod->getSortedDataInterface()->getOrdering(); + iamMap.insert({indexName, indexAccessMethod}); // Build the outer branch that produces the correlated local key slot. auto [localKeysSetSlot, localKeysSetStage] = buildKeySet(JoinSide::Local, @@ -747,10 +741,11 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( // Calculate the low key and high key of each individual local field. They are stored in // 'lowKeySlot' and 'highKeySlot', respectively. These two slots will be made available in - // the loop join stage to perform index seek. We also set the 'indexKeyPatternSlot' constant - // for the seek stage later to perform consistency check. + // the loop join stage to perform index seek. We also set 'indexIdSlot' and + // 'indexKeyPatternSlot' constants for the seek stage later to perform consistency check. auto lowKeySlot = slotIdGenerator.generate(); auto highKeySlot = slotIdGenerator.generate(); + auto indexIdSlot = slotIdGenerator.generate(); auto indexKeyPatternSlot = slotIdGenerator.generate(); auto [_, indexKeyPatternValue] = copyValue(TypeTags::bsonObject, bitcastFrom<const char*>(index.keyPattern.objdata())); @@ -777,6 +772,8 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( makeNewKeyStringCall(KeyString::Discriminator::kExclusiveBefore), highKeySlot, makeNewKeyStringCall(KeyString::Discriminator::kExclusiveAfter), + indexIdSlot, + makeConstant(indexName), indexKeyPatternSlot, makeConstant(value::TypeTags::bsonObject, indexKeyPatternValue)); @@ -797,14 +794,12 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( auto foreignRecordIdSlot = slotIdGenerator.generate(); auto indexKeySlot = slotIdGenerator.generate(); auto snapshotIdSlot = slotIdGenerator.generate(); - auto indexIdSlot = slotIdGenerator.generate(); auto ixScanStage = makeS<IndexScanStage>(foreignCollUUID, indexName, true /* forward */, indexKeySlot, foreignRecordIdSlot, snapshotIdSlot, - indexIdSlot, IndexKeysInclusionSet{} /* indexKeysToInclude */, makeSV() /* vars */, lowKeySlot, @@ -817,7 +812,7 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( auto ixScanNljStage = makeS<LoopJoinStage>(std::move(indexBoundKeyStage), std::move(ixScanStage), - makeSV(indexKeyPatternSlot) /* outerProjects */, + makeSV(indexIdSlot, indexKeyPatternSlot) /* outerProjects */, makeSV(lowKeySlot, highKeySlot) /* outerCorrelated */, nullptr /* predicate */, nodeId); @@ -837,7 +832,8 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( // Loop join the foreign record id produced by the index seek on the outer side with seek // stage on the inner side to get matched foreign documents. The foreign documents are // stored in 'foreignRecordSlot'. We also pass in 'snapshotIdSlot', 'indexIdSlot', - // 'indexKeySlot' and 'indexKeyPatternSlot' to perform index consistency check during the seek. + // 'indexKeySlot' and 'indexKeyPatternSlot' to perform index consistency check during the + // seek. auto [foreignRecordSlot, __, scanNljStage] = makeLoopJoinForFetch(std::move(ixScanNljStage), foreignRecordIdSlot, snapshotIdSlot, @@ -845,6 +841,7 @@ std::pair<SlotId, std::unique_ptr<sbe::PlanStage>> buildIndexJoinLookupStage( indexKeySlot, indexKeyPatternSlot, foreignColl, + iamMap, nodeId, makeSV() /* slotsToForward */, slotIdGenerator); @@ -1091,6 +1088,7 @@ std::pair<std::unique_ptr<sbe::PlanStage>, PlanStageSlots> SlotBasedStageBuilder eqLookupNode->joinFieldForeign, foreignColl, *eqLookupNode->idxEntry, + _data.iamMap, _yieldPolicy, collatorSlot, eqLookupNode->nodeId(), diff --git a/src/mongo/db/query/sbe_stage_builder_lookup_test.cpp b/src/mongo/db/query/sbe_stage_builder_lookup_test.cpp index bcc426984e8..b54872582eb 100644 --- a/src/mongo/db/query/sbe_stage_builder_lookup_test.cpp +++ b/src/mongo/db/query/sbe_stage_builder_lookup_test.cpp @@ -235,7 +235,7 @@ public: expectedDocuments.reserve(expectedPairs.size()); for (auto& [localDocument, matchedDocuments] : expectedPairs) { MutableDocument expectedDocument; - expectedDocument.reset(localDocument, false /* bsonHasMetadata */); + expectedDocument.reset(localDocument, false /* stripMetadata */); std::vector<mongo::Value> matchedValues{matchedDocuments.begin(), matchedDocuments.end()}; diff --git a/src/mongo/db/query/sbe_utils.cpp b/src/mongo/db/query/sbe_utils.cpp index 7f327848fc7..695b2904562 100644 --- a/src/mongo/db/query/sbe_utils.cpp +++ b/src/mongo/db/query/sbe_utils.cpp @@ -62,11 +62,9 @@ bool isQuerySbeCompatible(const CollectionPtr* collection, const bool doesNotHaveElemMatchProject = !cq->getProj() || !cq->getProj()->containsElemMatch(); - const bool isNotInnerSideOfLookup = !(expCtx && expCtx->inLookup); - return allExpressionsSupported && isNotCount && doesNotContainMetadataRequirements && isQueryNotAgainstTimeseriesCollection && isQueryNotAgainstClusteredCollection && doesNotSortOnMetaOrPathWithNumericComponents && isNotOplog && doesNotRequireMatchDetails && - doesNotHaveElemMatchProject && isNotInnerSideOfLookup; + doesNotHaveElemMatchProject; } } // namespace mongo::sbe diff --git a/src/mongo/db/query/sort_pattern.cpp b/src/mongo/db/query/sort_pattern.cpp index 5a444cd31f2..fcd3cd177e1 100644 --- a/src/mongo/db/query/sort_pattern.cpp +++ b/src/mongo/db/query/sort_pattern.cpp @@ -112,13 +112,13 @@ QueryMetadataBitSet SortPattern::metadataDeps(QueryMetadataBitSet unavailableMet return depsTracker.metadataDeps(); } -Document SortPattern::serialize(SortKeySerialization serializationMode, - const SerializationOptions& options) const { +Document SortPattern::serialize(SortKeySerialization serializationMode) const { MutableDocument keyObj; const size_t n = _sortPattern.size(); for (size_t i = 0; i < n; ++i) { if (_sortPattern[i].fieldPath) { - keyObj.setField(options.serializeFieldPath(*_sortPattern[i].fieldPath), + // Append a named integer based on whether the sort is ascending/descending. + keyObj.setField(_sortPattern[i].fieldPath->fullPath(), Value(_sortPattern[i].isAscending ? 1 : -1)); } else { // Sorting by an expression, use a made up field name. @@ -127,12 +127,7 @@ Document SortPattern::serialize(SortKeySerialization serializationMode, case SortKeySerialization::kForExplain: case SortKeySerialization::kForPipelineSerialization: { const bool isExplain = (serializationMode == SortKeySerialization::kForExplain); - auto opts = SerializationOptions{}; - if (isExplain) { - opts.verbosity = - boost::make_optional(ExplainOptions::Verbosity::kQueryPlanner); - } - keyObj[computedFieldName] = _sortPattern[i].expression->serialize(opts); + keyObj[computedFieldName] = _sortPattern[i].expression->serialize(isExplain); break; } case SortKeySerialization::kForSortKeyMerging: { diff --git a/src/mongo/db/query/sort_pattern.h b/src/mongo/db/query/sort_pattern.h index c709a43eac8..9c74208ac43 100644 --- a/src/mongo/db/query/sort_pattern.h +++ b/src/mongo/db/query/sort_pattern.h @@ -33,7 +33,6 @@ #include "mongo/db/exec/document_value/document.h" #include "mongo/db/pipeline/document_path_support.h" #include "mongo/db/pipeline/expression.h" -#include "mongo/db/query/query_shape/serialization_options.h" namespace mongo { class SortPattern { @@ -73,8 +72,7 @@ public: /** * Write out a Document whose contents are the sort key pattern. */ - Document serialize(SortKeySerialization serializationMode, - const SerializationOptions& options = {}) const; + Document serialize(SortKeySerialization) const; /** * Serializes the document to BSON, only keeping the paths specified in the sort pattern. @@ -149,6 +147,6 @@ private: std::vector<SortPatternPart> _sortPattern; // The set of paths on which we're sorting. - OrderedPathSet _paths; + std::set<std::string> _paths; }; } // namespace mongo diff --git a/src/mongo/db/query/sort_pattern_test.cpp b/src/mongo/db/query/sort_pattern_test.cpp deleted file mode 100644 index 2abe1bffa81..00000000000 --- a/src/mongo/db/query/sort_pattern_test.cpp +++ /dev/null @@ -1,97 +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 "query_shape/serialization_options.h" - -#include "mongo/db/exec/document_value/document.h" -#include "mongo/db/exec/document_value/document_value_test_util.h" -#include "mongo/db/exec/document_value/value.h" -#include "mongo/db/pipeline/expression_context_for_test.h" -#include "mongo/db/query/sort_pattern.h" -#include "mongo/unittest/unittest.h" -namespace mongo { -namespace { - -auto getExpCtx() { - auto nss = NamespaceString("db", "coll"); - return boost::intrusive_ptr<ExpressionContextForTest>{new ExpressionContextForTest(nss)}; -} - -TEST(SerializeSortPatternTest, SerializeAndRedactFieldName) { - auto expCtx = getExpCtx(); - auto sortPattern = SortPattern(fromjson("{val: 1}"), expCtx); - SerializationOptions opts = SerializationOptions::kMarkIdentifiers_FOR_TEST; - - // Most basic sort pattern, confirm that field name gets redacted. - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<val>":1})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); - - // Confirm that multiple sort fields get redacted. - sortPattern = SortPattern(fromjson("{val: 1, test: -1, third: -1}"), expCtx); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<val>":1,"HASH<test>":-1,"HASH<third>":-1})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); - - // Test sort pattern that contains an expression. - sortPattern = SortPattern(fromjson("{val: 1, test: {$meta: \"randVal\"}}"), expCtx); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<val>":1,"$computed1":{"$meta":"randVal"}})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); - - // Sorting by only an expression results in a made up field name in serialization and therefore - // doesn't get redacted. - sortPattern = SortPattern(fromjson("{val: {$meta: \"textScore\"}}"), expCtx); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"$computed0":{"$meta":"textScore"}})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); - - sortPattern = SortPattern(fromjson("{'a.b.c': 1}"), expCtx); - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"HASH<a>.HASH<b>.HASH<c>":1})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); -} - -TEST(SerializeSortPatternTest, SerializeNoRedaction) { - auto expCtx = getExpCtx(); - auto sortPattern = SortPattern(fromjson("{val: 1}"), expCtx); - SerializationOptions opts = {}; - opts.transformIdentifiers = false; - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"val":1})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization, opts)); - - // Call serialize() with no options. - ASSERT_DOCUMENT_EQ_AUTO( // NOLINT - R"({"val":1})", - sortPattern.serialize(SortPattern::SortKeySerialization::kForPipelineSerialization)); -} - -} // namespace -} // namespace mongo diff --git a/src/mongo/db/query/util/deferred.h b/src/mongo/db/query/util/deferred.h deleted file mode 100644 index a2609bb6b49..00000000000 --- a/src/mongo/db/query/util/deferred.h +++ /dev/null @@ -1,118 +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. - */ - -#pragma once - -#include <functional> - -namespace mongo { - -/** - * A template class that provides a way to defer the initialization of an object until its value is - * actually required. This is also commonly referred to as lazy initialization. - * - * Dangers: - * - This implementation is currently not thread safe, and it shouldn't be used in multi-threaded - * fashion. - * - Be careful about using this for lazy initialization of data members and capturing the 'this' - * variable. Code like this will result in buggy/unsafe move constructors, which would have a - * dangling reference to the moved-from type: - * - * class MyType { - * int x; - * // !!! Dangling 'this' when moved !!! - * Deferred<int> xSquared{[this]() { return this->x * this-> x; }; - * }; - * Instead, it is better to do something like this: - * class MyType { - * int xSquared() const { - * return *_xSquared.get(_x); - * } - * - * int _x; - * Deferred<int, int> _xSquared{[](int x) { return x * x; }; - * }; - * - As a similar danger, the value is only computed once. if you initialize it with arguments like - * the above 'xSquared()' implementation, then be cogniscent that the value will never change. If - * '_x' changes, '_xSquared' will not. - * - * A Deferred class can be constructed with either an initial value (eager initialization) or a - * function that will generate the value when needed. - */ -template <typename T, typename... Args> -class Deferred { -public: - /** - * Instantiates a Deffered<T> with the given data - no callbacks or lazy initialization. - */ - Deferred(T data) : _data(data) {} - - /** - * Stores a function to compute a T later. Please note the warnings described in this class - * comment. - */ - Deferred(std::function<T(Args&&...)> initializer) : _initializer(std::move(initializer)) {} - - /** - * Returns a pointer to the managed object. Initializes the object if it hasn't done so already. - */ - T& get(Args&&... args) const { - if (_initializer) { - _data = _initializer(std::forward<Args>(args)...); - _initializer = nullptr; - } - return _data; - } - - /** - * Dereferences the pointer to the managed object. Note this is only a valid shortcut if there - * are no arguments to '_initializer'. - */ - T* operator->() const { - return &get(); - } - - /** - * Returns a referenced to the managed object. Initializes the object if it hasn't done so - * already. Note this is only a valid shortcut if there are no arguments to '_initializer'. - */ - const T& operator*() const { - return get(); - } - - bool isInitialized() const { - return _initializer ? false : true; - } - -private: - mutable T _data; - mutable std::function<T(Args&&...)> _initializer; -}; - -} // namespace mongo diff --git a/src/mongo/db/query/util/deferred_test.cpp b/src/mongo/db/query/util/deferred_test.cpp deleted file mode 100644 index de256394787..00000000000 --- a/src/mongo/db/query/util/deferred_test.cpp +++ /dev/null @@ -1,98 +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 "mongo/db/query/util/deferred.h" - -#include "mongo/unittest/unittest.h" - -namespace mongo { -using std::string; -using namespace std::string_literals; - - -TEST(DeferredTest, EagerInitialization) { - Deferred<string> eager{"someString"}; - ASSERT_TRUE(eager.isInitialized()); - ASSERT_EQ(eager.get(), "someString"s); - ASSERT_EQ(*eager, "someString"s); -} - -TEST(DeferredTest, DeferredInitialization) { - size_t initializationCount = 0; - Deferred<string> deferred{[&]() { - initializationCount++; - return "someString"s; - }}; - ASSERT_FALSE(deferred.isInitialized()); - - // Ensure the deferred object wasn't initialized on creation. - ASSERT_EQ(initializationCount, 0); - - // Ensure that the deferred object is initialized on pointer dereferences. - ASSERT_FALSE(deferred->empty()); - ASSERT_TRUE(deferred.isInitialized()); - - ASSERT_EQ(initializationCount, 1); - - // Ensure that the content of the deferred object is equal to its raw counterpart, while also - // verifing that it is initialized at most once. - ASSERT_EQ(deferred.get(), "someString"s); - ASSERT_EQ(initializationCount, 1); -} - -TEST(DeferredTest, DeferredInitializationWithOneArgument) { - size_t initializationCount = 0; - Deferred<string, const string&> deferred{[&](const string& input) { - initializationCount++; - return "{" + input + "}"; - }}; - - // Ensure the deferred object wasn't initialized on creation. - ASSERT_EQ(initializationCount, 0); - - // Ensure that the content of the deferred object is equal to its raw counterpart, while also - // verifing that it is initialized at most once. - ASSERT_EQ(deferred.get("more curlies"), "{more curlies}"s); - ASSERT_EQ(initializationCount, 1); - - // Note that the value is cached, so it's not really valid to call it with a different argument. - ASSERT_EQ(deferred.get("merganser"), "{more curlies}"s); - ASSERT_EQ(initializationCount, 1); -} - -TEST(DeferredTest, DeferredInitializationWithTwoArgs) { - Deferred<string, const string&, const string&> deferred{ - [&](const auto& input, const auto& prefix) { return prefix + input; }}; - - ASSERT_EQ(deferred.get("cowbell", "more "), "more cowbell"s); - ASSERT_EQ(deferred.get("cowbell", "more "), "more cowbell"s); - ASSERT_EQ(deferred.get("cowbell", "less?"), "more cowbell"s); - ASSERT_EQ(deferred.get("tests", "better"), "more cowbell"s); -} -} // namespace mongo diff --git a/src/mongo/db/query/util/memory_util.cpp b/src/mongo/db/query/util/memory_util.cpp deleted file mode 100644 index 8a206deb2b7..00000000000 --- a/src/mongo/db/query/util/memory_util.cpp +++ /dev/null @@ -1,128 +0,0 @@ -/** - * Copyright (C) 2021-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. - */ - -#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kQuery - -#include "mongo/db/query/util/memory_util.h" - -#include <cstddef> -#include <pcrecpp.h> - -#include "mongo/logv2/log.h" -#include "mongo/util/processinfo.h" - - -namespace mongo::memory_util { - -StatusWith<MemoryUnits> parseUnitString(const std::string& strUnit) { - if (strUnit.empty()) { - return Status(ErrorCodes::Error{6007010}, "Unit value cannot be empty"); - } - - if (strUnit[0] == '%') { - return MemoryUnits::kPercent; - } else if (strUnit[0] == 'M' || strUnit[0] == 'm') { - return MemoryUnits::kMB; - } else if (strUnit[0] == 'G' || strUnit[0] == 'g') { - return MemoryUnits::kGB; - } - - return Status(ErrorCodes::Error{6007011}, "Incorrect unit value"); -} - -StatusWith<MemorySize> MemorySize::parse(const std::string& str) { - pcrecpp::RE_Options opt; - opt.set_caseless(true); - // Looks for a floating point number with followed by a unit suffix (MB, GB, %). - pcrecpp::RE re("\\s*(\\d+\\.?\\d*)\\s*(MB|GB|%)\\s*", opt); - - double size{}; - std::string strUnit{}; - if (!re.FullMatch(str, &size, &strUnit)) { - return {ErrorCodes::Error{6007012}, "Unable to parse memory size string"}; - } - - auto statusWithUnit = parseUnitString(strUnit); - if (!statusWithUnit.isOK()) { - return statusWithUnit.getStatus(); - } - return MemorySize{size, statusWithUnit.getValue()}; -} - -size_t convertToSizeInBytes(const MemorySize& memSize) { - constexpr size_t kBytesInMB = 1024 * 1024; - constexpr size_t kMBytesInGB = 1024; - - double sizeInMB = memSize.size; - - switch (memSize.units) { - case MemoryUnits::kPercent: - sizeInMB *= ProcessInfo::getMemSizeMB() / 100.0; - break; - case MemoryUnits::kMB: - break; - case MemoryUnits::kGB: - sizeInMB *= kMBytesInGB; - break; - } - - return static_cast<size_t>(sizeInMB * kBytesInMB); -} - -size_t getRequestedMemSizeInBytes(const MemorySize& memSize) { - size_t planCacheSize = convertToSizeInBytes(memSize); - uassert(5968001, - "Cache size must be at least 1KB * number of cores", - planCacheSize >= 1024 * ProcessInfo::getNumCores()); - return planCacheSize; -} - -/** - * Sets upper limit on a storage structure's size. Either that structure's maximumSize or to - * percentage of the total system's memory (both known at call site), whichever is smaller. - */ -size_t capMemorySize(size_t requestedSizeBytes, - size_t maximumSizeGB, - double percentTotalSystemMemory) { - constexpr size_t kBytesInGB = 1024 * 1024 * 1024; - // Express maximum size in bytes. - const size_t maximumSizeBytes = maximumSizeGB * kBytesInGB; - const memory_util::MemorySize limitToProcessSize{percentTotalSystemMemory, - memory_util::MemoryUnits::kPercent}; - const size_t limitToProcessSizeInBytes = convertToSizeInBytes(limitToProcessSize); - - // The size will be capped by the minimum of the two values defined above. - const size_t upperLimit = std::min(maximumSizeBytes, limitToProcessSizeInBytes); - - if (requestedSizeBytes > upperLimit) { - requestedSizeBytes = upperLimit; - } - return requestedSizeBytes; -} -} // namespace mongo::memory_util diff --git a/src/mongo/db/query/util/memory_util_test.cpp b/src/mongo/db/query/util/memory_util_test.cpp deleted file mode 100644 index 78f7b3098d6..00000000000 --- a/src/mongo/db/query/util/memory_util_test.cpp +++ /dev/null @@ -1,73 +0,0 @@ -/** - * Copyright (C) 2021-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 "mongo/db/query/util/memory_util.h" - -#include "mongo/unittest/unittest.h" - -namespace mongo::memory_util { - -bool operator==(const MemorySize& lhs, const MemorySize& rhs) { - constexpr double kEpsilon = 1e-10; - return std::abs(lhs.size - rhs.size) < kEpsilon && lhs.units == rhs.units; -} - -TEST(MemorySizeTest, ParseUnitStringPercent) { - ASSERT_TRUE(MemoryUnits::kPercent == parseUnitString("%")); -} - -TEST(MemorySizeTest, ParseUnitStringMB) { - ASSERT_TRUE(MemoryUnits::kMB == parseUnitString("MB")); - ASSERT_TRUE(MemoryUnits::kMB == parseUnitString("mb")); - ASSERT_TRUE(MemoryUnits::kMB == parseUnitString("mB")); - ASSERT_TRUE(MemoryUnits::kMB == parseUnitString("Mb")); -} - -TEST(MemorySizeTest, ParseUnitStringGB) { - ASSERT_TRUE(MemoryUnits::kGB == parseUnitString("GB")); - ASSERT_TRUE(MemoryUnits::kGB == parseUnitString("gb")); - ASSERT_TRUE(MemoryUnits::kGB == parseUnitString("gB")); - ASSERT_TRUE(MemoryUnits::kGB == parseUnitString("Gb")); -} - -TEST(MemorySizeTest, ParseUnitStringIncorrectValue) { - ASSERT_NOT_OK(parseUnitString("").getStatus()); - ASSERT_NOT_OK(parseUnitString(" ").getStatus()); - ASSERT_NOT_OK(parseUnitString("KB").getStatus()); -} - -TEST(MemorySizeTest, ParseMemorySize) { - ASSERT_TRUE((MemorySize{10.0, MemoryUnits::kPercent}) == MemorySize::parse("10%")); - ASSERT_TRUE((MemorySize{300.0, MemoryUnits::kMB}) == MemorySize::parse("300MB")); - ASSERT_TRUE((MemorySize{4.0, MemoryUnits::kGB}) == MemorySize::parse("4GB")); - ASSERT_TRUE((MemorySize{5.1, MemoryUnits::kPercent}) == MemorySize::parse(" 5.1%")); - ASSERT_TRUE((MemorySize{11.1, MemoryUnits::kMB}) == MemorySize::parse("11.1 mb")); - ASSERT_TRUE((MemorySize{12.1, MemoryUnits::kGB}) == MemorySize::parse(" 12.1 Gb ")); -} -} // namespace mongo::memory_util diff --git a/src/mongo/db/query/wildcard_multikey_paths.cpp b/src/mongo/db/query/wildcard_multikey_paths.cpp index eea11ccd4b5..fb27c8b34f5 100644 --- a/src/mongo/db/query/wildcard_multikey_paths.cpp +++ b/src/mongo/db/query/wildcard_multikey_paths.cpp @@ -31,7 +31,7 @@ #include "mongo/db/query/wildcard_multikey_paths.h" -#include "mongo/db/concurrency/exception_util.h" +#include "mongo/db/concurrency/write_conflict_exception.h" #include "mongo/db/index/wildcard_access_method.h" #include "mongo/db/query/index_bounds_builder.h" #include "mongo/db/record_id_helpers.h" |