SERVER-83215 Add generic logic to support fast paths that bypass the optimizer

Author: henrinikku

jstests/cqf/fast_paths/non_eligible_queries.js

@@ -0,0 +1,81 @@
+/**
+ * This test verifies that the optimizer fast path is not used for queries that would otherwise be
+ * eligible but contain operations the current fast path implementations don't support (e.g. a
+ * projection).
+ */
+import {planHasStage} from "jstests/libs/analyze_plan.js";
+import {
+    checkCascadesOptimizerEnabled,
+    checkFastPathEnabled,
+} from "jstests/libs/optimizer_utils.js";
+
+if (!checkCascadesOptimizerEnabled(db)) {
+    jsTestLog("Skipping test because the optimizer is not enabled");
+    quit();
+}
+
+if (!checkFastPathEnabled(db)) {
+    jsTestLog("Skipping test because fast paths are not enabled");
+    quit();
+}
+
+function assertNotUsingFastPath(explainCmd) {
+    const explain = assert.commandWorked(explainCmd);
+    assert(!planHasStage(db, explain, "FASTPATH"));
+}
+
+const coll = db.non_eligible_queries;
+coll.drop();
+
+{
+    // Empty find with a projection should not use fast path.
+    const explain = coll.explain().find({}, {b: 1}).finish();
+    assertNotUsingFastPath(explain);
+}
+{
+    // Empty find with a sort spec should not use fast path.
+    const explain = coll.explain().find({}).sort({b: 1}).finish();
+    assertNotUsingFastPath(explain);
+}
+{
+    // Empty find with limit should not use fast path.
+    const explain = coll.explain().find({}).limit(3).finish();
+    assertNotUsingFastPath(explain);
+}
+{
+    // Empty find with skip should not use fast path.
+    const explain = coll.explain().find({}).skip(3).finish();
+    assertNotUsingFastPath(explain);
+}
+{
+    // Pipeline with $project should not use fast path.
+    let explain = coll.explain().aggregate([{$match: {}}, {$project: {a: 1}}]);
+    assertNotUsingFastPath(explain);
+
+    explain = coll.explain().aggregate([{$project: {a: 1}}]);
+    assertNotUsingFastPath(explain);
+}
+{
+    // Pipeline with $sort should not use fast path.
+    let explain = coll.explain().aggregate([{$match: {}}, {$sort: {a: 1}}]);
+    assertNotUsingFastPath(explain);
+
+    explain = coll.explain().aggregate([{$sort: {a: 1}}]);
+    assertNotUsingFastPath(explain);
+}
+{
+    // Pipeline with $limit should not use fast path.
+    let explain = coll.explain().aggregate([{$match: {}}, {$limit: 3}]);
+    assertNotUsingFastPath(explain);
+
+    explain = coll.explain().aggregate([{$limit: 3}]);
+    assertNotUsingFastPath(explain);
+}
+{
+    // Pipeline with $skip should not use fast path.
+    let explain = coll.explain().aggregate([{$match: {}}, {$skip: 3}]);
+    assertNotUsingFastPath(explain);
+
+    explain = coll.explain().aggregate([{$skip: 3}]);
+    assertNotUsingFastPath(explain);
+}

jstests/libs/optimizer_utils.js

@@ -15,6 +15,13 @@ export function checkPlanCacheParameterization(theDB) {
     return false;
 }
 
+export function checkFastPathEnabled(theDB) {
+    const isDisabled =
+        theDB.adminCommand({getParameter: 1, internalCascadesOptimizerDisableFastPath: 1})
+            .internalCascadesOptimizerDisableFastPath;
+    return !isDisabled;
+}
+
 /**
  * Utility for checking if the experimental Cascades optimizer code path is enabled (checks
  * framework control for M4+).

jstests/noPassthrough/cqf_fast_paths_sharded.js

@@ -0,0 +1,61 @@
+/**
+ * This test verifies that the optimizer fast path is not used for queries against sharded
+ * collections.
+ */
+import {planHasStage} from "jstests/libs/analyze_plan.js";
+
+const bonsaiSettings = {
+    internalQueryFrameworkControl: "tryBonsai",
+    featureFlagCommonQueryFramework: true,
+    // TODO SERVER-80582: Uncomment this setting. Some sharding code calls empty find on an
+    // unsharded collection internally, which causes this test to fail as that fast path is not
+    // implemented yet. internalCascadesOptimizerDisableFastPath: false,
+};
+
+const st = new ShardingTest({
+    shards: 2,
+    mongos: 1,
+    other: {
+        shardOptions: {
+            setParameter: {
+                ...bonsaiSettings,
+                "failpoint.enableExplainInBonsai": tojson({mode: "alwaysOn"}),
+            }
+        },
+        mongosOptions: {setParameter: {...bonsaiSettings}},
+    }
+});
+
+const db = st.getDB("test");
+
+const coll = db[jsTestName()];
+coll.drop();
+
+assert.commandWorked(coll.insertMany([...Array(100).keys()].map(i => {
+    return {_id: i, a: 1};
+})));
+
+st.shardColl(coll.getName(), {_id: 1}, {_id: 50}, {_id: 51});
+
+function assertNotUsingFastPath(explainCmd) {
+    const explain = assert.commandWorked(explainCmd);
+    assert(!planHasStage(db, explain, "FASTPATH"));
+}
+
+{
+    // Empty find on a sharded collection should not use fast path.
+    const explain = coll.explain().find().finish();
+    assertNotUsingFastPath(explain);
+}
+{
+    // Pipeline with empty match on a sharded collection should not use fast path.
+    const explain = coll.explain().aggregate([{$match: {}}]);
+    assertNotUsingFastPath(explain);
+}
+{
+    // Empty aggregate on a sharded collection should not use fast path.
+    const explain = coll.explain().aggregate([]);
+    assertNotUsingFastPath(explain);
+}
+
+st.stop();

src/mongo/db/SConscript

@@ -1576,6 +1576,8 @@ execEnv.Library(
         'query/classic_stage_builder.cpp',
         'query/cost_model/on_coefficients_change_updater_impl.cpp',
         'query/cqf_command_utils.cpp',
+        'query/cqf_fast_paths.cpp',
+        'query/cqf_fast_paths_utils.cpp',
         'query/cqf_get_executor.cpp',
         'query/explain.cpp',
         'query/find.cpp',

src/mongo/db/commands/run_aggregate.cpp

@@ -100,6 +100,7 @@
 #include "mongo/db/query/collation/collator_interface.h"
 #include "mongo/db/query/collection_query_info.h"
 #include "mongo/db/query/cqf_command_utils.h"
+#include "mongo/db/query/cqf_fast_paths.h"
 #include "mongo/db/query/cqf_get_executor.h"
 #include "mongo/db/query/cursor_response.h"
 #include "mongo/db/query/explain.h"
@@ -1436,13 +1437,28 @@ Status runAggregate(OperationContext* opCtx,
             optimizer::QueryHints queryHints = getHintsFromQueryKnobs();
             const bool fastIndexNullHandling = queryHints._fastIndexNullHandling;
             auto timeBegin = Date_t::now();
-            auto maybeExec = getSBEExecutorViaCascadesOptimizer(opCtx,
-                                                                expCtx,
-                                                                nss,
-                                                                collections,
-                                                                std::move(queryHints),
-                                                                request.getHint(),
-                                                                pipeline.get());
+            auto maybeExec = [&] {
+                // If the query is eligible for a fast path, use the fast path plan instead of
+                // invoking the optimizer.
+                if (auto fastPathExec = optimizer::fast_path::tryGetSBEExecutorViaFastPath(
+                        opCtx,
+                        expCtx,
+                        nss,
+                        collections,
+                        request.getExplain().has_value(),
+                        request.getHint().has_value(),
+                        pipeline.get())) {
+                    return fastPathExec;
+                }
+
+                return getSBEExecutorViaCascadesOptimizer(opCtx,
+                                                          expCtx,
+                                                          nss,
+                                                          collections,
+                                                          std::move(queryHints),
+                                                          request.getHint(),
+                                                          pipeline.get());
+            }();
             if (maybeExec) {
                 // Pass ownership of the pipeline to the executor. This is done to allow binding of
                 // parameters to use views onto the constants living in the MatchExpression (in the

src/mongo/db/query/SConscript

@@ -449,6 +449,7 @@ env.CppUnitTest(
         "ce_mode_parameter_test.cpp",
         "classic_stage_builder_test.cpp",
         "count_command_test.cpp",
+        "cqf_fast_paths_test.cpp",
         "cursor_response_test.cpp",
         "query_shape/distinct_cmd_shape_test.cpp",
         "query_shape/find_cmd_shape_test.cpp",