SERVER-18589 Change makeAsFinCmd to accept optional<int> for limit

5 files changed, 74 insertions, 19 deletions

diff --git a/src/mongo/db/query/lite_parsed_query.cpp b/src/mongo/db/query/lite_parsed_query.cpp
index e0c7522cbe9..1b2ce795eb0 100644
--- a/src/mongo/db/query/lite_parsed_query.cpp
+++ b/src/mongo/db/query/lite_parsed_query.cpp
@@ -412,19 +412,23 @@ namespace {
     }
 
     // static
-    StatusWith<unique_ptr<LiteParsedQuery>> LiteParsedQuery::makeAsFindCmd(const std::string& ns,
-                                                                           const BSONObj& query,
-                                                                           int limit) {
+    StatusWith<unique_ptr<LiteParsedQuery>>
+    LiteParsedQuery::makeAsFindCmd(const NamespaceString& ns,
+                                   const BSONObj& query,
+                                   boost::optional<int> limit) {
         unique_ptr<LiteParsedQuery> pq(new LiteParsedQuery());
 
-        pq->_ns = ns;
+        pq->_fromCommand = true;
+        pq->_ns = ns.ns();
         pq->_filter = query.getOwned();
 
-        if (limit <= 0) {
-            return Status(ErrorCodes::BadValue, "limit value must be positive");
-        }
+        if (limit) {
+            if (limit <= 0) {
+                return Status(ErrorCodes::BadValue, "limit value must be positive");
+            }
 
-        pq->_limit = limit;
+            pq->_limit = std::move(limit);
+        }
 
         pq->addMetaProjection();
 
diff --git a/src/mongo/db/query/lite_parsed_query.h b/src/mongo/db/query/lite_parsed_query.h
index 07ca4a5ee09..de34ea0ffd6 100644
--- a/src/mongo/db/query/lite_parsed_query.h
+++ b/src/mongo/db/query/lite_parsed_query.h
@@ -76,9 +76,10 @@ namespace mongo {
          * Constructs a LiteParseQuery object that can be used to serialize to find command
          * BSON object.
          */
-        static StatusWith<std::unique_ptr<LiteParsedQuery>> makeAsFindCmd(const std::string& ns,
-                                                                          const BSONObj& query,
-                                                                          int limit);
+        static StatusWith<std::unique_ptr<LiteParsedQuery>>
+        makeAsFindCmd(const NamespaceString& ns,
+                      const BSONObj& query,
+                      boost::optional<int> limit);
 
         /**
          * Converts this LPQ into a find command.
diff --git a/src/mongo/db/query/lite_parsed_query_test.cpp b/src/mongo/db/query/lite_parsed_query_test.cpp
index 4e6a2eeff45..eeae7786d6a 100644
--- a/src/mongo/db/query/lite_parsed_query_test.cpp
+++ b/src/mongo/db/query/lite_parsed_query_test.cpp
@@ -264,11 +264,13 @@ namespace {
     }
 
     TEST(LiteParsedQueryTest, MakeFindCmd) {
-        auto result = LiteParsedQuery::makeAsFindCmd("testns", BSON("x" << 1), 2);
+        auto result = LiteParsedQuery::makeAsFindCmd(NamespaceString("test.ns"),
+                                                     BSON("x" << 1),
+                                                     2);
         ASSERT_OK(result.getStatus());
 
         auto&& lpq = result.getValue();
-        ASSERT_EQUALS("testns", lpq->ns());
+        ASSERT_EQUALS("test.ns", lpq->ns());
         ASSERT_EQUALS(BSON("x" << 1), lpq->getFilter());
         ASSERT_EQUALS(2, lpq->getLimit());
 
@@ -285,7 +287,7 @@ namespace {
 
         ASSERT_FALSE(lpq->getBatchSize());
 
-        ASSERT_FALSE(lpq->fromFindCommand());
+        ASSERT_TRUE(lpq->isFromFindCommand());
         ASSERT_FALSE(lpq->isExplain());
         ASSERT_FALSE(lpq->returnKey());
         ASSERT_FALSE(lpq->showRecordId());
@@ -300,6 +302,53 @@ namespace {
         ASSERT_FALSE(lpq->isPartial());
     }
 
+    TEST(LiteParsedQueryTest, MakeFindCmdNoLimit) {
+        auto result = LiteParsedQuery::makeAsFindCmd(NamespaceString("test.ns"),
+                                                     BSON("x" << 1),
+                                                     boost::none);
+        ASSERT_OK(result.getStatus());
+
+        auto&& lpq = result.getValue();
+        ASSERT_EQUALS("test.ns", lpq->ns());
+        ASSERT_EQUALS(BSON("x" << 1), lpq->getFilter());
+
+        ASSERT_EQUALS(BSONObj(), lpq->getProj());
+        ASSERT_EQUALS(BSONObj(), lpq->getSort());
+        ASSERT_EQUALS(BSONObj(), lpq->getHint());
+        ASSERT_EQUALS(BSONObj(), lpq->getMin());
+        ASSERT_EQUALS(BSONObj(), lpq->getMax());
+
+        ASSERT_EQUALS(0, lpq->getSkip());
+        ASSERT_EQUALS(0, lpq->getMaxScan());
+        ASSERT_EQUALS(0, lpq->getMaxTimeMS());
+        ASSERT_EQUALS(0, lpq->getOptions());
+
+        ASSERT_FALSE(lpq->getBatchSize());
+        ASSERT_FALSE(lpq->getLimit());
+
+        ASSERT_TRUE(lpq->isFromFindCommand());
+        ASSERT_FALSE(lpq->isExplain());
+        ASSERT_FALSE(lpq->returnKey());
+        ASSERT_FALSE(lpq->showRecordId());
+        ASSERT_FALSE(lpq->isSnapshot());
+        ASSERT_FALSE(lpq->hasReadPref());
+        ASSERT_FALSE(lpq->isTailable());
+        ASSERT_FALSE(lpq->isSlaveOk());
+        ASSERT_FALSE(lpq->isOplogReplay());
+        ASSERT_FALSE(lpq->isNoCursorTimeout());
+        ASSERT_FALSE(lpq->isAwaitData());
+        ASSERT_FALSE(lpq->isExhaust());
+        ASSERT_FALSE(lpq->isPartial());
+    }
+
+    TEST(LiteParsedQueryTest, MakeFindCmdBadLimit) {
+        auto status = LiteParsedQuery::makeAsFindCmd(NamespaceString("test.ns"),
+                                                     BSON("x" << 1),
+                                                     0).getStatus();
+        ASSERT_NOT_OK(status);
+        ASSERT_EQUALS(ErrorCodes::BadValue, status.code());
+    }
+
     //
     // Text meta BSON element validation
     //
diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp b/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp
index 781cf0bd62f..105d206f364 100644
--- a/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp
+++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set.cpp
@@ -326,7 +326,7 @@ namespace {
         auto findStatus = _find(readHostStatus.getValue(),
                                 NamespaceString(ChunkType::ConfigNS),
                                 query.obj,
-                                0); // no limit
+                                boost::none); // no limit
         if (!findStatus.isOK()) {
             return findStatus.getStatus();
         }
@@ -367,7 +367,7 @@ namespace {
         auto findStatus = _find(readHost.getValue(),
                                 NamespaceString(ShardType::ConfigNS),
                                 BSONObj(), // no query filter
-                                0); // no limit
+                                boost::none); // no limit
         if (!findStatus.isOK()) {
             return findStatus.getStatus();
         }
@@ -526,7 +526,7 @@ namespace {
     StatusWith<vector<BSONObj>> CatalogManagerReplicaSet::_find(const HostAndPort& host,
                                                                 const NamespaceString& nss,
                                                                 const BSONObj& query,
-                                                                int limit) {
+                                                                boost::optional<int> limit) {
 
         // If for some reason the callback never gets invoked, we will return this status
         Status status = Status(ErrorCodes::InternalError, "Internal error running find command");
@@ -551,7 +551,7 @@ namespace {
         };
 
         unique_ptr<LiteParsedQuery> findCmd(
-            fassertStatusOK(28688, LiteParsedQuery::makeAsFindCmd(nss.toString(), query, limit)));
+            fassertStatusOK(28688, LiteParsedQuery::makeAsFindCmd(nss, query, std::move(limit))));
 
         QueryFetcher fetcher(grid.shardRegistry()->getExecutor(),
                              host,
diff --git a/src/mongo/s/catalog/replset/catalog_manager_replica_set.h b/src/mongo/s/catalog/replset/catalog_manager_replica_set.h
index 34d65779557..b78b0a17943 100644
--- a/src/mongo/s/catalog/replset/catalog_manager_replica_set.h
+++ b/src/mongo/s/catalog/replset/catalog_manager_replica_set.h
@@ -28,6 +28,7 @@
 
 #pragma once
 
+#include <boost/optional.hpp>
 #include <memory>
 #include <mutex>
 #include <string>
@@ -148,7 +149,7 @@ namespace mongo {
         StatusWith<std::vector<BSONObj>> _find(const HostAndPort& host,
                                                const NamespaceString& nss,
                                                const BSONObj& query,
-                                               int limit);
+                                               boost::optional<int> limit);
 
         /**
          * Runs a command against the specified host and returns the result.