CXX-722: add MaxAwaitTimeMs option to find opts

Author: Machyne

src/mongocxx/collection.cpp

@@ -133,10 +133,16 @@ cursor collection::find(bsoncxx::document::view filter, const options::find& opt
         rp_ptr = options.read_preference()->_impl->read_preference_t;
     }
 
-    return cursor(libmongoc::collection_find(
+    auto mongoc_cursor = libmongoc::collection_find(
         _impl->collection_t, mongoc_query_flags_t(0), options.skip().value_or(0),
         options.limit().value_or(0), options.batch_size().value_or(0), filter_bson.bson(),
-        projection.bson(), rp_ptr));
+        projection.bson(), rp_ptr);
+
+    if (options.max_await_time_ms()) {
+        libmongoc::cursor_set_max_await_time_ms(mongoc_cursor, *options.max_await_time_ms());
+    }
+
+    return cursor{mongoc_cursor};
 }
 
 stdx::optional<bsoncxx::document::value> collection::find_one(bsoncxx::document::view filter,

src/mongocxx/options/find.cpp

@@ -34,14 +34,18 @@ void find::comment(std::string comment) {
     _comment = comment;
 }
 
-void find::cursor_type(enum cursor_type cursor_type) {
+void find::cursor_type(enum find::cursor_type cursor_type) {
     _cursor_type = cursor_type;
 }
 
 void find::limit(std::int32_t limit) {
     _limit = limit;
 }
 
+void find::max_await_time_ms(std::int64_t max_await_time_ms) {
+    _max_await_time_ms = max_await_time_ms;
+}
+
 void find::max_time_ms(std::int64_t max_time_ms) {
     _max_time_ms = max_time_ms;
 }
@@ -86,14 +90,18 @@ const stdx::optional<std::string>& find::comment() const {
     return _comment;
 }
 
-const stdx::optional<cursor_type>& find::cursor_type() const {
+const stdx::optional<enum find::cursor_type>& find::cursor_type() const {
     return _cursor_type;
 }
 
 const stdx::optional<std::int32_t>& find::limit() const {
     return _limit;
 }
 
+const stdx::optional<std::int64_t>& find::max_await_time_ms() const {
+    return _max_await_time_ms;
+}
+
 const stdx::optional<std::int64_t>& find::max_time_ms() const {
     return _max_time_ms;
 }

src/mongocxx/options/find.hpp

@@ -26,14 +26,12 @@ namespace mongocxx {
 MONGOCXX_INLINE_NAMESPACE_BEGIN
 namespace options {
 
-enum class cursor_type : std::uint8_t { k_non_tailable, k_tailable, k_tailable_await };
-
 ///
 /// Class representing the optional arguments to a MongoDB query.
 ///
 class MONGOCXX_API find {
-
    public:
+    enum class cursor_type : std::uint8_t { k_non_tailable, k_tailable, k_tailable_await };
 
     ///
     /// Sets whether to allow partial results from a mongos if some shards are down (instead of
@@ -128,6 +126,29 @@ class MONGOCXX_API find {
     ///
     const stdx::optional<std::int32_t>& limit() const;
 
+    ///
+    /// The maximum amount of time for the server to wait on new documents to satisfy a tailable
+    /// cursor query. This only applies to a TAILABLE_AWAIT cursor. When the cursor is not a
+    /// TAILABLE_AWAIT cursor, this option is ignored. The default on the server is to wait for one
+    /// second.
+    ///
+    /// @note On servers < 3.2, this option is ignored.
+    ///
+    /// @param max_await_time_ms
+    ///   The max amount of time (in milliseconds) to wait for new documents.
+    ///
+    /// @see http://docs.mongodb.org/manual/reference/operator/meta/maxTimeMS
+    ///
+    void max_await_time_ms(std::int64_t max_await_time_ms);
+
+    ///
+    /// The maximum amount of time for the server to wait on new documents to satisfy a tailable
+    /// cursor query.
+    ///
+    /// @return The current max await time (in milliseconds).
+    ///
+    const stdx::optional<std::int64_t>& max_await_time_ms() const;
+
     ///
     /// Sets the maximum amount of time for this operation to run (server-side) in milliseconds.
     ///
@@ -271,6 +292,7 @@ class MONGOCXX_API find {
     stdx::optional<std::string> _comment;
     stdx::optional<enum cursor_type> _cursor_type;
     stdx::optional<std::int32_t> _limit;
+    stdx::optional<std::int64_t> _max_await_time_ms;
     stdx::optional<std::int64_t> _max_time_ms;
     stdx::optional<bsoncxx::document::view> _modifiers;
     stdx::optional<bool> _no_cursor_timeout;

src/mongocxx/private/libmongoc_symbols.hpp

@@ -63,6 +63,7 @@ MONGOCXX_LIBMONGOC_SYMBOL(collection_set_write_concern)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_destroy)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_error)
 MONGOCXX_LIBMONGOC_SYMBOL(cursor_next)
+MONGOCXX_LIBMONGOC_SYMBOL(cursor_set_max_await_time_ms)
 MONGOCXX_LIBMONGOC_SYMBOL(database_command)
 MONGOCXX_LIBMONGOC_SYMBOL(database_command_simple)
 MONGOCXX_LIBMONGOC_SYMBOL(database_create_collection)

src/mongocxx/test/CMakeLists.txt

@@ -15,6 +15,7 @@ set(mongocxx_test_sources
     model/update_many.cpp
     options/aggregate.cpp
     options/create_collection.cpp
+    options/find.cpp
     options/insert.cpp
     options/update.cpp
     pool.cpp

src/mongocxx/test/options/find.cpp

@@ -0,0 +1,28 @@
+#include "catch.hpp"
+#include "helpers.hpp"
+
+#include <bsoncxx/document/view.hpp>
+#include <mongocxx/options/find.hpp>
+
+using namespace mongocxx;
+
+TEST_CASE("find", "[find][option]") {
+    options::find find_opts{};
+    using cursor_type = enum options::find::cursor_type;
+
+    CHECK_OPTIONAL_ARGUMENT(find_opts, allow_partial_results, true);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, batch_size, 3);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, comment, "comment");
+    CHECK_OPTIONAL_ARGUMENT(find_opts, cursor_type, cursor_type::k_non_tailable);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, limit, 3);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, max_await_time_ms, 300);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, max_time_ms, 300);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, no_cursor_timeout, true);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, oplog_replay, true);
+    CHECK_OPTIONAL_ARGUMENT(find_opts, skip, 3);
+
+    CHECK_OPTIONAL_ARGUMENT_WITHOUT_EQUALITY(find_opts, read_preference, read_preference{});
+    CHECK_OPTIONAL_ARGUMENT(find_opts, modifiers, bsoncxx::document::view{});
+    CHECK_OPTIONAL_ARGUMENT(find_opts, projection, bsoncxx::document::view{});
+    CHECK_OPTIONAL_ARGUMENT(find_opts, sort, bsoncxx::document::view{});
+}