CDRIVER-1137 use read pref for count and collStats

mongoc_collection_count and mongoc_collection_stats now default to the
collection's read preference.

Author: ajdavis

NEWS

@@ -17,6 +17,12 @@ Server Selection Spec. These are the affected functions:
   * mongoc_collection_command
   * mongoc_collection_command_simple
 
+On the other hand, the following command-specific helper functions now use the
+collection's read preference:
+
+  * mongoc_collection_count
+  * mongoc_collection_stats
+
 New functions to send maxTimeMS or any arbitrary options with findAndModify:
 
   * mongoc_find_and_modify_opts_set_max_time_ms

build/generate-future-functions.py

@@ -139,6 +139,17 @@
                      param("const_mongoc_read_prefs_ptr", "read_prefs"),
                      param("bson_error_ptr", "error")]),
 
+    future_function("int64_t",
+                    "mongoc_collection_count_with_opts",
+                    [param("mongoc_collection_ptr", "collection"),
+                     param("mongoc_query_flags_t", "flags"),
+                     param("const_bson_ptr", "query"),
+                     param("int64_t", "skip"),
+                     param("int64_t", "limit"),
+                     param("const_bson_ptr", "opts"),
+                     param("const_mongoc_read_prefs_ptr", "read_prefs"),
+                     param("bson_error_ptr", "error")]),
+
     future_function("bool",
                     "mongoc_collection_find_and_modify_with_opts",
                     [param("mongoc_collection_ptr", "collection"),
@@ -160,6 +171,13 @@
                      param("bson_ptr", "reply"),
                      param("bson_error_ptr", "error")]),
 
+    future_function("bool",
+                    "mongoc_collection_stats",
+                    [param("mongoc_collection_ptr", "collection"),
+                     param("const_bson_ptr", "options"),
+                     param("bson_ptr", "stats"),
+                     param("bson_error_ptr", "error")]),
+
     future_function("bool",
                     "mongoc_collection_insert",
                     [param("mongoc_collection_ptr", "collection"),

doc/mongoc_collection_count.page

@@ -43,7 +43,7 @@ mongoc_collection_count (mongoc_collection_t       *collection,
     <title>Description</title>
     <p>This function shall execute a count query on the underlying 'collection'. The bson 'query' is not validated, simply passed along as appropriate to the server.  As such, compatibility and errors should be validated in the appropriate server documentation.</p>
     <p>For more information, see the <link href="http://docs.mongodb.org/manual/reference/operator/query/">query reference</link> at the MongoDB website.</p>
-    <note style="tip"><p>The <code xref="mongoc_read_concern_t">mongoc_read_concern_t</code> specified on the <code xref="mongoc_collection_t">mongoc_collection_t</code> will be used, if any.</p></note>
+    <p>The <code xref="mongoc_read_concern_t">mongoc_read_concern_t</code> specified on the <code xref="mongoc_collection_t">mongoc_collection_t</code> will be used, if any. If <code>read_prefs</code> is NULL, the collection's read preferences are used.</p>
   </section>
 
   <section id="errors">

doc/mongoc_collection_stats.page

@@ -25,14 +25,15 @@ mongoc_collection_stats (mongoc_collection_t *collection,
     <table>
       <tr><td><p>collection</p></td><td><p>A <code xref="mongoc_collection_t">mongoc_collection_t</code>.</p></td></tr>
       <tr><td><p>options</p></td><td><p>An optional <code xref="bson:bson_t">bson_t</code> containing extra options to pass to the <code>collStats</code> command.</p></td></tr>
-      <tr><td><p>reply</p></td><td><p>An optional location for a <code xref="bson:bson_t">bson_t</code> to store the result.</p></td></tr>
+      <tr><td><p>reply</p></td><td><p>An uninitialized <code xref="bson:bson_t">bson_t</code> to store the result.</p></td></tr>
       <tr><td><p>error</p></td><td><p>An optional location for a <code xref="bson:bson_error_t">bson_error_t</code> or <code>NULL</code>.</p></td></tr>
     </table>
   </section>
 
   <section id="description">
     <title>Description</title>
-    <p>This function is a helper to retrieve statistics about the collection.</p>
+    <p>Run the <code>collStats</code> command to retrieve statistics about the collection.</p>
+    <p>The command uses the <code xref="mongoc_read_prefs_t">mongoc_read_prefs_t</code> set on <code>collection</code>.</p>
   </section>
 
   <section id="errors">
@@ -42,8 +43,8 @@ mongoc_collection_stats (mongoc_collection_t *collection,
 
   <section id="return">
     <title>Returns</title>
-    <p>true if successful</p>
-    <p><code>reply</code> is always initialized to simplfiy memory handling.</p>
+    <p>True if successful.</p>
+    <p><code>reply</code> is always initialized and must be freed with <code xref="bson:bson_destroy">bson_destroy</code>.</p>
   </section>
 
 </page>

src/mongoc/mongoc-collection.c

@@ -630,14 +630,17 @@ mongoc_collection_count (mongoc_collection_t       *collection,  /* IN */
                          const mongoc_read_prefs_t *read_prefs,  /* IN */
                          bson_error_t              *error)       /* OUT */
 {
+   /* Server Selection Spec: "may-use-secondary" commands SHOULD take a read
+    * preference argument and otherwise MUST use the default read preference
+    * from client, database or collection configuration. */
    return mongoc_collection_count_with_opts (
       collection,
       flags,
       query,
       skip,
       limit,
       NULL,
-      read_prefs,
+      read_prefs ? read_prefs : collection->read_prefs,
       error);
 }
 
@@ -654,25 +657,24 @@ mongoc_collection_count_with_opts (mongoc_collection_t       *collection,  /* IN
 {
    mongoc_server_stream_t *server_stream;
    mongoc_cluster_t *cluster;
+   mongoc_apply_read_prefs_result_t read_prefs_result = READ_PREFS_RESULT_INIT;
    bson_iter_t iter;
    int64_t ret = -1;
    bool success;
    bson_t reply;
-   bson_t cmd;
+   bson_t cmd = BSON_INITIALIZER;
    bson_t q;
 
    ENTRY;
 
-
    cluster = &collection->client->cluster;
    server_stream = mongoc_cluster_stream_for_writes (cluster, error);
    if (!server_stream) {
-      RETURN (-1);
+      GOTO (done);
    }
 
    BSON_ASSERT (collection);
 
-   bson_init(&cmd);
    bson_append_utf8(&cmd, "count", 5, collection->collection,
                     collection->collectionlen);
    if (query) {
@@ -696,9 +698,7 @@ mongoc_collection_count_with_opts (mongoc_collection_t       *collection,  /* IN
                          MONGOC_ERROR_COMMAND,
                          MONGOC_ERROR_PROTOCOL_BAD_WIRE_VERSION,
                          "The selected server does not support readConcern");
-         bson_destroy (&cmd);
-         mongoc_server_stream_cleanup (server_stream);
-         RETURN (-1);
+         GOTO (done);
       }
 
       read_concern_bson = _mongoc_read_concern_get_bson (collection->read_concern);
@@ -708,18 +708,23 @@ mongoc_collection_count_with_opts (mongoc_collection_t       *collection,  /* IN
        bson_concat(&cmd, opts);
    }
 
-   success = mongoc_cluster_run_command_monitored (cluster,
-                                                   server_stream,
-                                                   MONGOC_QUERY_SLAVE_OK,
-                                                   collection->db,
-                                                   &cmd, &reply, error);
+   apply_read_preferences (read_prefs, server_stream,
+                           &cmd, flags, &read_prefs_result);
+
+   success = mongoc_cluster_run_command_monitored (
+      cluster, server_stream, read_prefs_result.flags, collection->db,
+      read_prefs_result.query_with_read_prefs, &reply, error);
 
    if (success && bson_iter_init_find(&iter, &reply, "n")) {
       ret = bson_iter_as_int64(&iter);
    }
+
    bson_destroy (&reply);
-   bson_destroy (&cmd);
+
+done:
+   apply_read_prefs_result_cleanup (&read_prefs_result);
    mongoc_server_stream_cleanup (server_stream);
+   bson_destroy (&cmd);
 
    RETURN (ret);
 }
@@ -2053,7 +2058,12 @@ mongoc_collection_stats (mongoc_collection_t *collection,
       bson_concat (&cmd, options);
    }
 
-   ret = mongoc_collection_command_simple (collection, &cmd, NULL, stats, error);
+   /* Server Selection Spec: "may-use-secondary" commands SHOULD take a read
+    * preference argument and otherwise MUST use the default read preference
+    * from client, database or collection configuration. */
+   ret = mongoc_collection_command_simple (collection, &cmd,
+                                           collection->read_prefs,
+                                           stats, error);
 
    bson_destroy (&cmd);
 

tests/mock_server/future-functions.c

@@ -135,6 +135,32 @@ background_mongoc_collection_count (void *data)
    return NULL;
 }
 
+static void *
+background_mongoc_collection_count_with_opts (void *data)
+{
+   future_t *future = (future_t *) data;
+   future_value_t return_value;
+
+   return_value.type = future_value_int64_t_type;
+
+   future_value_set_int64_t (
+      &return_value,
+      mongoc_collection_count_with_opts (
+         future_value_get_mongoc_collection_ptr (future_get_param (future, 0)),
+         future_value_get_mongoc_query_flags_t (future_get_param (future, 1)),
+         future_value_get_const_bson_ptr (future_get_param (future, 2)),
+         future_value_get_int64_t (future_get_param (future, 3)),
+         future_value_get_int64_t (future_get_param (future, 4)),
+         future_value_get_const_bson_ptr (future_get_param (future, 5)),
+         future_value_get_const_mongoc_read_prefs_ptr (future_get_param (future, 6)),
+         future_value_get_bson_error_ptr (future_get_param (future, 7))
+      ));
+
+   future_resolve (future, return_value);
+
+   return NULL;
+}
+
 static void *
 background_mongoc_collection_find_and_modify_with_opts (void *data)
 {
@@ -186,6 +212,28 @@ background_mongoc_collection_find_and_modify (void *data)
    return NULL;
 }
 
+static void *
+background_mongoc_collection_stats (void *data)
+{
+   future_t *future = (future_t *) data;
+   future_value_t return_value;
+
+   return_value.type = future_value_bool_type;
+
+   future_value_set_bool (
+      &return_value,
+      mongoc_collection_stats (
+         future_value_get_mongoc_collection_ptr (future_get_param (future, 0)),
+         future_value_get_const_bson_ptr (future_get_param (future, 1)),
+         future_value_get_bson_ptr (future_get_param (future, 2)),
+         future_value_get_bson_error_ptr (future_get_param (future, 3))
+      ));
+
+   future_resolve (future, return_value);
+
+   return NULL;
+}
+
 static void *
 background_mongoc_collection_insert (void *data)
 {
@@ -627,6 +675,48 @@ future_collection_count (
    return future;
 }
 
+future_t *
+future_collection_count_with_opts (
+   mongoc_collection_ptr collection,
+   mongoc_query_flags_t flags,
+   const_bson_ptr query,
+   int64_t skip,
+   int64_t limit,
+   const_bson_ptr opts,
+   const_mongoc_read_prefs_ptr read_prefs,
+   bson_error_ptr error)
+{
+   future_t *future = future_new (future_value_int64_t_type,
+                                  8);
+   
+   future_value_set_mongoc_collection_ptr (
+      future_get_param (future, 0), collection);
+   
+   future_value_set_mongoc_query_flags_t (
+      future_get_param (future, 1), flags);
+   
+   future_value_set_const_bson_ptr (
+      future_get_param (future, 2), query);
+   
+   future_value_set_int64_t (
+      future_get_param (future, 3), skip);
+   
+   future_value_set_int64_t (
+      future_get_param (future, 4), limit);
+   
+   future_value_set_const_bson_ptr (
+      future_get_param (future, 5), opts);
+   
+   future_value_set_const_mongoc_read_prefs_ptr (
+      future_get_param (future, 6), read_prefs);
+   
+   future_value_set_bson_error_ptr (
+      future_get_param (future, 7), error);
+   
+   future_start (future, background_mongoc_collection_count_with_opts);
+   return future;
+}
+
 future_t *
 future_collection_find_and_modify_with_opts (
    mongoc_collection_ptr collection,
@@ -707,6 +797,32 @@ future_collection_find_and_modify (
    return future;
 }
 
+future_t *
+future_collection_stats (
+   mongoc_collection_ptr collection,
+   const_bson_ptr options,
+   bson_ptr stats,
+   bson_error_ptr error)
+{
+   future_t *future = future_new (future_value_bool_type,
+                                  4);
+   
+   future_value_set_mongoc_collection_ptr (
+      future_get_param (future, 0), collection);
+   
+   future_value_set_const_bson_ptr (
+      future_get_param (future, 1), options);
+   
+   future_value_set_bson_ptr (
+      future_get_param (future, 2), stats);
+   
+   future_value_set_bson_error_ptr (
+      future_get_param (future, 3), error);
+   
+   future_start (future, background_mongoc_collection_stats);
+   return future;
+}
+
 future_t *
 future_collection_insert (
    mongoc_collection_ptr collection,

tests/mock_server/future-functions.h

@@ -67,6 +67,20 @@ future_collection_count (
 );
 
 
+future_t *
+future_collection_count_with_opts (
+
+   mongoc_collection_ptr collection,
+   mongoc_query_flags_t flags,
+   const_bson_ptr query,
+   int64_t skip,
+   int64_t limit,
+   const_bson_ptr opts,
+   const_mongoc_read_prefs_ptr read_prefs,
+   bson_error_ptr error
+);
+
+
 future_t *
 future_collection_find_and_modify_with_opts (
 
@@ -94,6 +108,16 @@ future_collection_find_and_modify (
 );
 
 
+future_t *
+future_collection_stats (
+
+   mongoc_collection_ptr collection,
+   const_bson_ptr options,
+   bson_ptr stats,
+   bson_error_ptr error
+);
+
+
 future_t *
 future_collection_insert (