SERVER-51649 Convert aggregate command input to IDL

5 files changed, 41 insertions, 40 deletions

diff --git a/src/mongo/db/views/SConscript b/src/mongo/db/views/SConscript
index a03a9cd2fad..602a5710255 100644
--- a/src/mongo/db/views/SConscript
+++ b/src/mongo/db/views/SConscript
@@ -42,6 +42,7 @@ env.Library(
     ],
     LIBDEPS=[
         '$BUILD_DIR/mongo/base',
+        '$BUILD_DIR/mongo/db/pipeline/aggregation_request_helper',
     ]
 )
 
diff --git a/src/mongo/db/views/resolved_view.cpp b/src/mongo/db/views/resolved_view.cpp
index 5bb17093d21..bccc3562d06 100644
--- a/src/mongo/db/views/resolved_view.cpp
+++ b/src/mongo/db/views/resolved_view.cpp
@@ -33,7 +33,6 @@
 
 #include "mongo/base/init.h"
 #include "mongo/bson/bsonobjbuilder.h"
-#include "mongo/db/pipeline/aggregation_request.h"
 #include "mongo/rpc/get_status_from_command_result.h"
 
 namespace mongo {
@@ -87,8 +86,7 @@ std::shared_ptr<const ErrorExtraInfo> ResolvedView::parse(const BSONObj& cmdRepl
     return std::make_shared<ResolvedView>(fromBSON(cmdReply));
 }
 
-AggregationRequest ResolvedView::asExpandedViewAggregation(
-    const AggregationRequest& request) const {
+AggregateCommand ResolvedView::asExpandedViewAggregation(const AggregateCommand& request) const {
     // Perform the aggregation on the resolved namespace.  The new pipeline consists of two parts:
     // first, 'pipeline' in this ResolvedView; then, the pipeline in 'request'.
     std::vector<BSONObj> resolvedPipeline;
@@ -97,7 +95,7 @@ AggregationRequest ResolvedView::asExpandedViewAggregation(
     resolvedPipeline.insert(
         resolvedPipeline.end(), request.getPipeline().begin(), request.getPipeline().end());
 
-    AggregationRequest expandedRequest{_namespace, resolvedPipeline};
+    AggregateCommand expandedRequest{_namespace, resolvedPipeline};
 
     if (request.getExplain()) {
         expandedRequest.setExplain(request.getExplain());
@@ -109,10 +107,10 @@ AggregationRequest ResolvedView::asExpandedViewAggregation(
     expandedRequest.setMaxTimeMS(request.getMaxTimeMS());
     expandedRequest.setReadConcern(request.getReadConcern());
     expandedRequest.setUnwrappedReadPref(request.getUnwrappedReadPref());
-    expandedRequest.setBypassDocumentValidation(request.shouldBypassDocumentValidation());
-    expandedRequest.setAllowDiskUse(request.shouldAllowDiskUse());
+    expandedRequest.setBypassDocumentValidation(request.getBypassDocumentValidation());
+    expandedRequest.setAllowDiskUse(request.getAllowDiskUse());
     expandedRequest.setIsMapReduceCommand(request.getIsMapReduceCommand());
-    expandedRequest.setLetParameters(request.getLetParameters());
+    expandedRequest.setLet(request.getLet());
 
     // Operations on a view must always use the default collation of the view. We must have already
     // checked that if the user's request specifies a collation, it matches the collation of the
diff --git a/src/mongo/db/views/resolved_view.h b/src/mongo/db/views/resolved_view.h
index 9ab61fe105e..aa931189c2a 100644
--- a/src/mongo/db/views/resolved_view.h
+++ b/src/mongo/db/views/resolved_view.h
@@ -34,7 +34,7 @@
 #include "mongo/base/status_with.h"
 #include "mongo/bson/bsonobj.h"
 #include "mongo/db/namespace_string.h"
-#include "mongo/db/pipeline/aggregation_request.h"
+#include "mongo/db/pipeline/aggregate_command_gen.h"
 
 namespace mongo {
 
@@ -57,7 +57,7 @@ public:
      * Convert an aggregation command on a view to the equivalent command against the view's
      * underlying collection.
      */
-    AggregationRequest asExpandedViewAggregation(const AggregationRequest& aggRequest) const;
+    AggregateCommand asExpandedViewAggregation(const AggregateCommand& aggRequest) const;
 
     const NamespaceString& getNamespace() const {
         return _namespace;
diff --git a/src/mongo/db/views/resolved_view_test.cpp b/src/mongo/db/views/resolved_view_test.cpp
index a3a60d9e102..0a795870986 100644
--- a/src/mongo/db/views/resolved_view_test.cpp
+++ b/src/mongo/db/views/resolved_view_test.cpp
@@ -37,7 +37,7 @@
 #include "mongo/bson/json.h"
 #include "mongo/db/exec/document_value/document.h"
 #include "mongo/db/namespace_string.h"
-#include "mongo/db/pipeline/aggregation_request.h"
+#include "mongo/db/pipeline/aggregation_request_helper.h"
 #include "mongo/db/views/resolved_view.h"
 #include "mongo/rpc/get_status_from_command_result.h"
 #include "mongo/unittest/unittest.h"
@@ -48,36 +48,38 @@ namespace {
 const NamespaceString viewNss("testdb.testview");
 const NamespaceString backingNss("testdb.testcoll");
 const std::vector<BSONObj> emptyPipeline;
-const BSONObj kDefaultCursorOptionDocument =
-    BSON(AggregationRequest::kBatchSizeName << AggregationRequest::kDefaultBatchSize);
+const BSONObj kDefaultCursorOptionDocument = BSON(aggregation_request_helper::kBatchSizeField
+                                                  << aggregation_request_helper::kDefaultBatchSize);
 const BSONObj kSimpleCollation;
 
 TEST(ResolvedViewTest, ExpandingAggRequestWithEmptyPipelineOnNoOpViewYieldsEmptyPipeline) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest requestOnView{viewNss, emptyPipeline};
+    AggregateCommand requestOnView{viewNss, emptyPipeline};
 
     auto result = resolvedView.asExpandedViewAggregation(requestOnView);
-    BSONObj expected = BSON("aggregate" << backingNss.coll() << "pipeline" << BSONArray()
-                                        << "cursor" << kDefaultCursorOptionDocument);
-    ASSERT_BSONOBJ_EQ(result.serializeToCommandObj().toBson(), expected);
+    BSONObj expected =
+        BSON("aggregate" << backingNss.coll() << "pipeline" << BSONArray() << "cursor"
+                         << kDefaultCursorOptionDocument << "collation" << BSONObj());
+    ASSERT_BSONOBJ_EQ(aggregation_request_helper::serializeToCommandObj(result), expected);
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestWithNonemptyPipelineAppendsToViewPipeline) {
     std::vector<BSONObj> viewPipeline{BSON("skip" << 7)};
     const ResolvedView resolvedView{backingNss, viewPipeline, kSimpleCollation};
-    AggregationRequest requestOnView{viewNss, std::vector<BSONObj>{BSON("limit" << 3)}};
+    AggregateCommand requestOnView{viewNss, std::vector<BSONObj>{BSON("limit" << 3)}};
 
     auto result = resolvedView.asExpandedViewAggregation(requestOnView);
 
-    BSONObj expected = BSON("aggregate" << backingNss.coll() << "pipeline"
-                                        << BSON_ARRAY(BSON("skip" << 7) << BSON("limit" << 3))
-                                        << "cursor" << kDefaultCursorOptionDocument);
-    ASSERT_BSONOBJ_EQ(result.serializeToCommandObj().toBson(), expected);
+    BSONObj expected =
+        BSON("aggregate" << backingNss.coll() << "pipeline"
+                         << BSON_ARRAY(BSON("skip" << 7) << BSON("limit" << 3)) << "cursor"
+                         << kDefaultCursorOptionDocument << "collation" << BSONObj());
+    ASSERT_BSONOBJ_EQ(aggregation_request_helper::serializeToCommandObj(result), expected);
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesExplain) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest{viewNss, {}};
+    AggregateCommand aggRequest{viewNss, {}};
     aggRequest.setExplain(ExplainOptions::Verbosity::kExecStats);
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
@@ -87,74 +89,74 @@ TEST(ResolvedViewTest, ExpandingAggRequestPreservesExplain) {
 
 TEST(ResolvedViewTest, ExpandingAggRequestWithCursorAndExplainOnlyPreservesExplain) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest{viewNss, {}};
+    AggregateCommand aggRequest{viewNss, {}};
     aggRequest.setBatchSize(10);
     aggRequest.setExplain(ExplainOptions::Verbosity::kExecStats);
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
     ASSERT(result.getExplain());
     ASSERT(*result.getExplain() == ExplainOptions::Verbosity::kExecStats);
-    ASSERT_EQ(result.getBatchSize(), AggregationRequest::kDefaultBatchSize);
+    ASSERT_EQ(result.getBatchSize(), aggregation_request_helper::kDefaultBatchSize);
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesBypassDocumentValidation) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setBypassDocumentValidation(true);
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_TRUE(result.shouldBypassDocumentValidation());
+    ASSERT_TRUE(result.getBypassDocumentValidation().value_or(false));
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesAllowDiskUse) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setAllowDiskUse(true);
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_TRUE(result.shouldAllowDiskUse());
+    ASSERT_TRUE(result.getAllowDiskUse());
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesHint) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setHint(BSON("a" << 1));
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_BSONOBJ_EQ(result.getHint(), BSON("a" << 1));
+    ASSERT_BSONOBJ_EQ(result.getHint().value_or(BSONObj()), BSON("a" << 1));
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesReadPreference) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setUnwrappedReadPref(BSON("$readPreference"
                                          << "nearest"));
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_BSONOBJ_EQ(result.getUnwrappedReadPref(),
+    ASSERT_BSONOBJ_EQ(result.getUnwrappedReadPref().value_or(BSONObj()),
                       BSON("$readPreference"
                            << "nearest"));
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesReadConcern) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setReadConcern(BSON("level"
                                    << "linearizable"));
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_BSONOBJ_EQ(result.getReadConcern(),
+    ASSERT_BSONOBJ_EQ(result.getReadConcern().value_or(BSONObj()),
                       BSON("level"
                            << "linearizable"));
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesMaxTimeMS) {
     const ResolvedView resolvedView{backingNss, emptyPipeline, kSimpleCollation};
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
     aggRequest.setMaxTimeMS(100u);
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_EQ(result.getMaxTimeMS(), 100u);
+    ASSERT_EQ(result.getMaxTimeMS().value_or(0), 100u);
 }
 
 TEST(ResolvedViewTest, ExpandingAggRequestPreservesDefaultCollationOfView) {
@@ -165,10 +167,10 @@ TEST(ResolvedViewTest, ExpandingAggRequestPreservesDefaultCollationOfView) {
     ASSERT_BSONOBJ_EQ(resolvedView.getDefaultCollation(),
                       BSON("locale"
                            << "fr_CA"));
-    AggregationRequest aggRequest(viewNss, {});
+    AggregateCommand aggRequest(viewNss, {});
 
     auto result = resolvedView.asExpandedViewAggregation(aggRequest);
-    ASSERT_BSONOBJ_EQ(result.getCollation(),
+    ASSERT_BSONOBJ_EQ(result.getCollation().value_or(BSONObj()),
                       BSON("locale"
                            << "fr_CA"));
 }
diff --git a/src/mongo/db/views/view_catalog.cpp b/src/mongo/db/views/view_catalog.cpp
index d90c180bb97..359799159eb 100644
--- a/src/mongo/db/views/view_catalog.cpp
+++ b/src/mongo/db/views/view_catalog.cpp
@@ -43,7 +43,7 @@
 #include "mongo/db/catalog/database.h"
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
-#include "mongo/db/pipeline/aggregation_request.h"
+#include "mongo/db/pipeline/aggregate_command_gen.h"
 #include "mongo/db/pipeline/document_source.h"
 #include "mongo/db/pipeline/expression_context.h"
 #include "mongo/db/pipeline/lite_parsed_pipeline.h"
@@ -404,7 +404,7 @@ StatusWith<stdx::unordered_set<NamespaceString>> ViewCatalog::_validatePipeline(
     }
     boost::intrusive_ptr<ExpressionContext> expCtx =
         new ExpressionContext(opCtx,
-                              AggregationRequest(viewDef.viewOn(), viewDef.pipeline()),
+                              AggregateCommand(viewDef.viewOn(), viewDef.pipeline()),
                               CollatorInterface::cloneCollator(viewDef.defaultCollator()),
                               // We can use a stub MongoProcessInterface because we are only parsing
                               // the Pipeline for validation here. We won't do anything with the