Clean up of estimated_document_count (#1645)

Control flow of estimated_document_count is needlessly complex when we
have C99 available to mix declarations. This fixes a false-positive in
static analysis on reply_local being destroyed while uninitialized.

Author: vector-of-bool

src/libmongoc/src/mongoc/mongoc-collection.c

@@ -17,6 +17,7 @@
 
 #include <stdio.h>
 
+#include "bson/bson.h"
 #include "mongoc-aggregate-private.h"
 #include "mongoc-bulk-operation.h"
 #include "mongoc-bulk-operation-private.h"
@@ -766,57 +767,49 @@ mongoc_collection_estimated_document_count (mongoc_collection_t *coll,
                                             bson_t *reply,
                                             bson_error_t *error)
 {
-   bson_iter_t iter;
-   int64_t count = -1;
-   bool ret;
-   bson_t reply_local;
-   bson_t *reply_ptr;
-   bson_t cmd = BSON_INITIALIZER;
-   mongoc_server_stream_t *server_stream = NULL;
-
    ENTRY;
 
    BSON_ASSERT_PARAM (coll);
 
-   server_stream = mongoc_cluster_stream_for_reads (&coll->client->cluster, read_prefs, NULL, NULL, reply, error);
-
+   // No sessionId allowed
    if (opts && bson_has_field (opts, "sessionId")) {
       bson_set_error (error,
                       MONGOC_ERROR_COMMAND,
                       MONGOC_ERROR_COMMAND_INVALID_ARG,
                       "Collection count must not specify explicit session");
-      GOTO (done);
+      RETURN (-1);
    }
 
-   reply_ptr = reply ? reply : &reply_local;
-
-   BSON_APPEND_UTF8 (&cmd, "count", coll->collection);
-   ret = _mongoc_client_command_with_opts (coll->client,
-                                           coll->db,
-                                           &cmd,
-                                           MONGOC_CMD_READ,
-                                           opts,
-                                           MONGOC_QUERY_NONE,
-                                           read_prefs,
-                                           coll->read_prefs,
-                                           coll->read_concern,
-                                           coll->write_concern,
-                                           reply_ptr,
-                                           error);
-   if (ret) {
-      if (bson_iter_init_find (&iter, reply_ptr, "n")) {
-         count = bson_iter_as_int64 (&iter);
-      }
-   }
+   // Storage for the reply if no storage was given by caller
+   bson_t reply_local = BSON_INITIALIZER;
+   // Write the reply to either the caller's storage or a local variable
+   bson_t *const reply_ptr = reply ? reply : &reply_local;
+
+   // Create and execute a "count" command
+   bsonBuildDecl (cmd, kv ("count", cstr (coll->collection)));
+   const bool command_ok = _mongoc_client_command_with_opts (coll->client,
+                                                             coll->db,
+                                                             &cmd,
+                                                             MONGOC_CMD_READ,
+                                                             opts,
+                                                             MONGOC_QUERY_NONE,
+                                                             read_prefs,
+                                                             coll->read_prefs,
+                                                             coll->read_concern,
+                                                             coll->write_concern,
+                                                             reply_ptr,
+                                                             error);
+   bson_destroy (&cmd);
 
-done:
-   if (!reply) {
-      bson_destroy (&reply_local);
+   // Extract the "n" field from the response
+   int64_t ret_count = -1;
+   if (command_ok) {
+      bsonParse (*reply_ptr, find (key ("n"), do (ret_count = bson_iter_as_int64 (&bsonVisitIter))));
    }
-   bson_destroy (&cmd);
-   mongoc_server_stream_cleanup (server_stream);
+   // Destroy the local storage. This is a no-op if we used the caller's storage.
+   bson_destroy (&reply_local);
 
-   RETURN (count);
+   RETURN (ret_count);
 }