•

Tutorial

/* gcc example-pool.c -o example-pool $(pkg-config --cflags --libs


 * libmongoc-1.0) */
/* ./example-pool [CONNECTION_STRING] */
#include <mongoc.h>
#include <pthread.h>
#include <stdio.h>
static pthread_mutex_t mutex;
static bool in_shutdown = false;
static void *
worker (void *data)
{


   mongoc_client_pool_t *pool = data;


   mongoc_client_t *client;


   bson_t ping = BSON_INITIALIZER;


   bson_error_t error;


   bool r;


   BSON_APPEND_INT32 (&ping, "ping", 1);


   while (true) {


      client = mongoc_client_pool_pop (pool);


      /* Do something with client. If you are writing an HTTP server, you


       * probably only want to hold onto the client for the portion of the


       * request performing database queries.


       */


      r = mongoc_client_command_simple (


         client, "admin", &ping, NULL, NULL, &error);


      if (!r) {


         fprintf (stderr, "%s\n", error.message);


      }


      mongoc_client_pool_push (pool, client);


      pthread_mutex_lock (&mutex);


      if (in_shutdown || !r) {


         pthread_mutex_unlock (&mutex);


         break;


      }


      pthread_mutex_unlock (&mutex);


   }


   bson_destroy (&ping);


   return NULL;
}
int
main (int argc, char *argv[])
{


   const char *uristr = "mongodb://127.0.0.1/?appname=pool-example";


   mongoc_uri_t *uri;


   mongoc_client_pool_t *pool;


   pthread_t threads[10];


   unsigned i;


   void *ret;


   pthread_mutex_init (&mutex, NULL);


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   uri = mongoc_uri_new (uristr);


   if (!uri) {


      fprintf (stderr, "Failed to parse URI: \"%s\".\n", uristr);


      return EXIT_FAILURE;


   }


   pool = mongoc_client_pool_new (uri);


   mongoc_client_pool_set_error_api (pool, 2);


   for (i = 0; i < 10; i++) {


      pthread_create (&threads[i], NULL, worker, pool);


   }


   sleep (10);


   pthread_mutex_lock (&mutex);


   in_shutdown = true;


   pthread_mutex_unlock (&mutex);


   for (i = 0; i < 10; i++) {


      pthread_join (threads[i], &ret);


   }


   mongoc_client_pool_destroy (pool);


   mongoc_uri_destroy (uri);


   mongoc_cleanup ();


   return 0;
}

• CANONICALIZE_HOST_NAME: This might be required when the hosts report different hostnames than what is used in the kerberos database. The default is "false".
• SERVICE_NAME: Use a different service name than the default, "mongodb".

• Did you call mongoc_init() in main()? If not, you will likely see a segfault.
• Have you leaked any clients or cursors as can be found with mongoc-stat <PID>?
• Have packets been delivered to the server? See egress bytes from mongoc-stat <PID>.
• Does valgrind show any leaks? Ensure you call mongoc_cleanup() at the end of your process to cleanup lingering allocations from the MongoDB C driver.
• If compiling your own copy of MongoDB C driver, consider configuring with --enable-tracing to enable function tracing and hex dumps of network packets to STDERR and STDOUT.

• Active and Disposed Cursors
• Active and Disposed Clients, Client Pools, and Socket Streams.
• Number of operations sent and received, by type.
• Bytes transferred and received.
• Authentication successes and failures.
• Number of wire protocol errors.

• Create an account and login.
• Navigate to the CDRIVER project.
• Click Create Issue - Please provide as much information as possible about the issue type and how to reproduce it.

/* Don't try to compile this file on its own. It's meant to be #included


   by example code */
/* Insert some sample data */
bool
insert_data (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   enum N { ndocs = 4 };


   bson_t *docs[ndocs];


   bson_error_t error;


   int i = 0;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   docs[0] = BCON_NEW ("x", BCON_DOUBLE (1.0), "tags", "[", "dog", "cat", "]");


   docs[1] = BCON_NEW ("x", BCON_DOUBLE (2.0), "tags", "[", "cat", "]");


   docs[2] = BCON_NEW (


      "x", BCON_DOUBLE (2.0), "tags", "[", "mouse", "cat", "dog", "]");


   docs[3] = BCON_NEW ("x", BCON_DOUBLE (3.0), "tags", "[", "]");


   for (i = 0; i < ndocs; i++) {


      mongoc_bulk_operation_insert (bulk, docs[i]);


      bson_destroy (docs[i]);


      docs[i] = NULL;


   }


   ret = mongoc_bulk_operation_execute (bulk, NULL, &error);


   if (!ret) {


      fprintf (stderr, "Error inserting data: %s\n", error.message);


   }


   mongoc_bulk_operation_destroy (bulk);


   return ret;
}
/* A helper which we'll use a lot later on */
void
print_res (const bson_t *reply)
{


   BSON_ASSERT (reply);


   char *str = bson_as_json (reply, NULL);


   printf ("%s\n", str);


   bson_free (str);
}

bool
explain (mongoc_collection_t *collection)
{


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   command = BCON_NEW ("explain",


                       "{",


                       "find",


                       BCON_UTF8 (COLLECTION_NAME),


                       "filter",


                       "{",


                       "x",


                       BCON_INT32 (1),


                       "}",


                       "}");


   res = mongoc_collection_command_simple (


      collection, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with explain: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply */


   print_res (&reply);
cleanup:


   bson_destroy (&reply);


   bson_destroy (command);


   return res;
}

bool
copydb (mongoc_client_t *client, const char *other_host_and_port)
{


   mongoc_database_t *admindb;


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   BSON_ASSERT (other_host_and_port);


   /* Must do this from the admin db */


   admindb = mongoc_client_get_database (client, "admin");


   command = BCON_NEW ("copydb",


                       BCON_INT32 (1),


                       "fromdb",


                       BCON_UTF8 ("test"),


                       "todb",


                       BCON_UTF8 ("test2"),


                       /* If you want from a different host */


                       "fromhost",


                       BCON_UTF8 (other_host_and_port));


   res =


      mongoc_database_command_simple (admindb, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with copydb: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply */


   print_res (&reply);
cleanup:


   bson_destroy (&reply);


   bson_destroy (command);


   mongoc_database_destroy (admindb);


   return res;
}

bool
clone_collection (mongoc_database_t *database, const char *other_host_and_port)
{


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   BSON_ASSERT (other_host_and_port);


   command = BCON_NEW ("cloneCollection",


                       BCON_UTF8 ("test.remoteThings"),


                       "from",


                       BCON_UTF8 (other_host_and_port),


                       "query",


                       "{",


                       "x",


                       BCON_INT32 (1),


                       "}");


   res =


      mongoc_database_command_simple (database, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with clone: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply */


   print_res (&reply);
cleanup:


   bson_destroy (&reply);


   bson_destroy (command);


   return res;
}

/*


 * Copyright 2016 MongoDB, Inc.


 *


 * Licensed under the Apache License, Version 2.0 (the "License");


 * you may not use this file except in compliance with the License.


 * You may obtain a copy of the License at


 *


 *   http://www.apache.org/licenses/LICENSE-2.0


 *


 * Unless required by applicable law or agreed to in writing, software


 * distributed under the License is distributed on an "AS IS" BASIS,


 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.


 * See the License for the specific language governing permissions and


 * limitations under the License.


 */
#include <mongoc.h>
#include <stdio.h>
const char *COLLECTION_NAME = "things";
#include "../doc-common-insert.c"
#include "explain.c"
#include "copydb.c"
#include "clone-collection.c"
int
main (int argc, char *argv[])
{


   mongoc_database_t *database = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *collection = NULL;


   char *host_and_port;


   int res = 0;


   char *other_host_and_port = NULL;


   if (argc < 2 || argc > 3) {


      fprintf (stderr,


               "usage: %s MONGOD-1-CONNECTION-STRING "


               "[MONGOD-2-HOST-NAME:MONGOD-2-PORT]\n",


               argv[0]);


      fprintf (stderr,


               "MONGOD-1-CONNECTION-STRING can be "


               "of the following forms:\n");


      fprintf (stderr, "localhost\t\t\t\tlocal machine\n");


      fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n");


      fprintf (stderr,


               "mongodb://user:pass@localhost:27017\t"


               "local machine on port 27017, and authenticate with username "


               "user and password pass\n");


      return 1;


   }


   mongoc_init ();


   if (strncmp (argv[1], "mongodb://", 10) == 0) {


      host_and_port = bson_strdup (argv[1]);


   } else {


      host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]);


   }


   other_host_and_port = argc > 2 ? argv[2] : NULL;


   client = mongoc_client_new (host_and_port);


   if (!client) {


      fprintf (stderr, "Invalid hostname or port: %s\n", host_and_port);


      res = 2;


      goto cleanup;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "test");


   collection = mongoc_database_get_collection (database, COLLECTION_NAME);


   printf ("Inserting data\n");


   if (!insert_data (collection)) {


      res = 3;


      goto cleanup;


   }


   printf ("explain\n");


   if (!explain (collection)) {


      res = 4;


      goto cleanup;


   }


   if (other_host_and_port) {


      printf ("copydb\n");


      if (!copydb (client, other_host_and_port)) {


         res = 5;


         goto cleanup;


      }


      printf ("clone collection\n");


      if (!clone_collection (database, other_host_and_port)) {


         res = 6;


         goto cleanup;


      }


   }
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   bson_free (host_and_port);


   mongoc_cleanup ();


   return res;
}

#include <bson.h>
#include <mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef _WIN32
#define sleep(_n) Sleep ((_n) *1000)
#endif
static void
print_bson (const bson_t *b)
{


   char *str;


   str = bson_as_json (b, NULL);


   fprintf (stdout, "%s\n", str);


   bson_free (str);
}
static mongoc_cursor_t *
query_collection (mongoc_collection_t *collection, uint32_t last_time)
{


   mongoc_cursor_t *cursor;


   bson_t query;


   bson_t gt;


   bson_t opts;


   BSON_ASSERT (collection);


   bson_init (&query);


   BSON_APPEND_DOCUMENT_BEGIN (&query, "ts", &gt);


   BSON_APPEND_TIMESTAMP (&gt, "$gt", last_time, 0);


   bson_append_document_end (&query, &gt);


   bson_init (&opts);


   BSON_APPEND_BOOL (&opts, "tailable", true);


   BSON_APPEND_BOOL (&opts, "awaitData", true);


   cursor = mongoc_collection_find_with_opts (collection, &query, &opts, NULL);


   bson_destroy (&query);


   bson_destroy (&opts);


   return cursor;
}
static void
tail_collection (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   uint32_t last_time;


   const bson_t *doc;


   bson_error_t error;


   bson_iter_t iter;


   BSON_ASSERT (collection);


   last_time = (uint32_t) time (NULL);


   while (true) {


      cursor = query_collection (collection, last_time);


      while (!mongoc_cursor_error (cursor, &error) &&


             mongoc_cursor_more (cursor)) {


         if (mongoc_cursor_next (cursor, &doc)) {


            if (bson_iter_init_find (&iter, doc, "ts") &&


                BSON_ITER_HOLDS_TIMESTAMP (&iter)) {


               bson_iter_timestamp (&iter, &last_time, NULL);


            }


            print_bson (doc);


         }


      }


      if (mongoc_cursor_error (cursor, &error)) {


         if (error.domain == MONGOC_ERROR_SERVER) {


            fprintf (stderr, "%s\n", error.message);


            exit (1);


         }


      }


      mongoc_cursor_destroy (cursor);


      sleep (1);


   }
}
int
main (int argc, char *argv[])
{


   mongoc_collection_t *collection;


   mongoc_client_t *client;


   if (argc != 2) {


      fprintf (stderr, "usage: %s MONGO_URI\n", argv[0]);


      return EXIT_FAILURE;


   }


   mongoc_init ();


   client = mongoc_client_new (argv[1]);


   if (!client) {


      fprintf (stderr, "Invalid URI: \"%s\"\n", argv[1]);


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "local", "oplog.rs");


   tail_collection (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   return 0;
}

#include <assert.h>
#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk1 (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   int i;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   for (i = 0; i < 10000; i++) {


      doc = BCON_NEW ("i", BCON_INT32 (i));


      mongoc_bulk_operation_insert (bulk, doc);


      bson_destroy (doc);


   }


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      fprintf (stderr, "Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk1-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk1 (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <assert.h>
#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk2 (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *query;


   bson_t *doc;


   bson_t *opts;


   bson_t reply;


   char *str;


   bool ret;


   int i;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   /* Remove everything */


   query = bson_new ();


   mongoc_bulk_operation_remove (bulk, query);


   bson_destroy (query);


   /* Add a few documents */


   for (i = 1; i < 4; i++) {


      doc = BCON_NEW ("_id", BCON_INT32 (i));


      mongoc_bulk_operation_insert (bulk, doc);


      bson_destroy (doc);


   }


   /* {_id: 1} => {$set: {foo: "bar"}} */


   query = BCON_NEW ("_id", BCON_INT32 (1));


   doc = BCON_NEW ("$set", "{", "foo", BCON_UTF8 ("bar"), "}");


   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, NULL, &error);


   bson_destroy (query);


   bson_destroy (doc);


   /* {_id: 4} => {'$inc': {'j': 1}} (upsert) */


   opts = BCON_NEW ("upsert", BCON_BOOL (true));


   query = BCON_NEW ("_id", BCON_INT32 (4));


   doc = BCON_NEW ("$inc", "{", "j", BCON_INT32 (1), "}");


   mongoc_bulk_operation_update_many_with_opts (bulk, query, doc, opts, &error);


   bson_destroy (query);


   bson_destroy (doc);


   bson_destroy (opts);


   /* replace {j:1} with {j:2} */


   query = BCON_NEW ("j", BCON_INT32 (1));


   doc = BCON_NEW ("j", BCON_INT32 (2));


   mongoc_bulk_operation_replace_one_with_opts (bulk, query, doc, NULL, &error);


   bson_destroy (query);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk2-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk2 (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <assert.h>
#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk3 (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *query;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   /* false indicates unordered */


   bulk = mongoc_collection_create_bulk_operation (collection, false, NULL);


   /* Add a document */


   doc = BCON_NEW ("_id", BCON_INT32 (1));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* remove {_id: 2} */


   query = BCON_NEW ("_id", BCON_INT32 (2));


   mongoc_bulk_operation_remove_one (bulk, query);


   bson_destroy (query);


   /* insert {_id: 3} */


   doc = BCON_NEW ("_id", BCON_INT32 (3));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* replace {_id:4} {'i': 1} */


   query = BCON_NEW ("_id", BCON_INT32 (4));


   doc = BCON_NEW ("i", BCON_INT32 (1));


   mongoc_bulk_operation_replace_one (bulk, query, doc, false);


   bson_destroy (query);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk3-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk3 (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <assert.h>
#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk5_fail (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (31));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (32));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* The above documents do not comply to the schema validation rules


    * we created previously, so this will result in an error */


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
static void
bulk5_success (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   /* Allow this document to bypass document validation.


    * NOTE: When authentication is enabled, the authenticated user must have


    * either the "dbadmin" or "restore" roles to bypass document validation */


   mongoc_bulk_operation_set_bypass_document_validation (bulk, true);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (31));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (32));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (int argc, char *argv[])
{


   bson_t *options;


   bson_error_t error;


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_database_t *database;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk5-example");


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "testasdf");


   /* Create schema validator */


   options = BCON_NEW (


      "validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");


   collection =


      mongoc_database_create_collection (database, "collname", options, &error);


   if (collection) {


      bulk5_fail (collection);


      bulk5_success (collection);


      mongoc_collection_destroy (collection);


   } else {


      fprintf (stderr, "Couldn't create collection: '%s'\n", error.message);


   }


   bson_free (options);


   mongoc_database_destroy (database);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <assert.h>
#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk4 (mongoc_collection_t *collection)
{


   mongoc_write_concern_t *wc;


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t reply;


   char *str;


   bool ret;


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_w (wc, 4);


   mongoc_write_concern_set_wtimeout (wc, 100); /* milliseconds */


   bulk = mongoc_collection_create_bulk_operation (collection, true, wc);


   /* Two inserts */


   doc = BCON_NEW ("_id", BCON_INT32 (10));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_INT32 (11));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);


   mongoc_write_concern_destroy (wc);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk4-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk4 (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk_collation (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   bson_t *opts;


   bson_t *doc;


   bson_t *selector;


   bson_t *update;


   bson_error_t error;


   bson_t reply;


   char *str;


   uint32_t ret;


   /* insert {_id: "one"} and {_id: "One"} */


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   doc = BCON_NEW ("_id", BCON_UTF8 ("one"));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   doc = BCON_NEW ("_id", BCON_UTF8 ("One"));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   /* "One" normally sorts before "one"; make "one" come first */


   opts = BCON_NEW ("collation",


                    "{",


                    "locale",


                    BCON_UTF8 ("en_US"),


                    "caseFirst",


                    BCON_UTF8 ("lower"),


                    "}");


   /* set x=1 on the document with _id "One", which now sorts after "one" */


   update = BCON_NEW ("$set", "{", "x", BCON_INT64 (1), "}");


   selector = BCON_NEW ("_id", "{", "$gt", BCON_UTF8 ("one"), "}");


   mongoc_bulk_operation_update_one_with_opts (


      bulk, selector, update, opts, &error);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (selector);


   bson_destroy (opts);


   mongoc_bulk_operation_destroy (bulk);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk-collation");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "db", "collection");


   bulk_collation (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <bcon.h>
#include <mongoc.h>
#include <stdio.h>
static void
bulk6 (mongoc_collection_t *collection)
{


   mongoc_write_concern_t *wc;


   mongoc_bulk_operation_t *bulk;


   bson_error_t error;


   bson_t *doc;


   bson_t *selector;


   bson_t reply;


   char *str;


   bool ret;


   wc = mongoc_write_concern_new ();


   mongoc_write_concern_set_w (wc, 0);


   bulk = mongoc_collection_create_bulk_operation (collection, true, wc);


   doc = BCON_NEW ("_id", BCON_INT32 (10));


   mongoc_bulk_operation_insert (bulk, doc);


   bson_destroy (doc);


   selector = BCON_NEW ("_id", BCON_INT32 (11));


   mongoc_bulk_operation_remove_one (bulk, selector);


   bson_destroy (selector);


   ret = mongoc_bulk_operation_execute (bulk, &reply, &error);


   str = bson_as_json (&reply, NULL);


   printf ("%s\n", str);


   bson_free (str);


   if (!ret) {


      printf ("Error: %s\n", error.message);


   }


   bson_destroy (&reply);


   mongoc_bulk_operation_destroy (bulk);


   mongoc_write_concern_destroy (wc);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new ("mongodb://localhost/?appname=bulk6-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "test");


   bulk6 (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

• The _id field holds the zipcode as a string.
• The city field holds the city name.
• The state field holds the two letter state abbreviation.
• The pop field holds the population.
• The loc field holds the location as a [latitude, longitude] array.

#include <mongoc.h>
#include <stdio.h>
static void
print_pipeline (mongoc_collection_t *collection)
{


   mongoc_cursor_t *cursor;


   bson_error_t error;


   const bson_t *doc;


   bson_t *pipeline;


   char *str;


   pipeline = BCON_NEW ("pipeline",


                        "[",


                        "{",


                        "$group",


                        "{",


                        "_id",


                        "$state",


                        "total_pop",


                        "{",


                        "$sum",


                        "$pop",


                        "}",


                        "}",


                        "}",


                        "{",


                        "$match",


                        "{",


                        "total_pop",


                        "{",


                        "$gte",


                        BCON_INT32 (10000000),


                        "}",


                        "}",


                        "}",


                        "]");


   cursor = mongoc_collection_aggregate (


      collection, MONGOC_QUERY_NONE, pipeline, NULL, NULL);


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_json (doc, NULL);


      printf ("%s\n", str);


      bson_free (str);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "Cursor Failure: %s\n", error.message);


   }


   mongoc_cursor_destroy (cursor);


   bson_destroy (pipeline);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_init ();


   client = mongoc_client_new (


      "mongodb://localhost:27017?appname=aggregation-example");


   mongoc_client_set_error_api (client, 2);


   collection = mongoc_client_get_collection (client, "test", "zipcodes");


   print_pipeline (collection);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

/* Don't try to compile this file on its own. It's meant to be #included


   by example code */
/* Insert some sample data */
bool
insert_data (mongoc_collection_t *collection)
{


   mongoc_bulk_operation_t *bulk;


   enum N { ndocs = 4 };


   bson_t *docs[ndocs];


   bson_error_t error;


   int i = 0;


   bool ret;


   bulk = mongoc_collection_create_bulk_operation (collection, true, NULL);


   docs[0] = BCON_NEW ("x", BCON_DOUBLE (1.0), "tags", "[", "dog", "cat", "]");


   docs[1] = BCON_NEW ("x", BCON_DOUBLE (2.0), "tags", "[", "cat", "]");


   docs[2] = BCON_NEW (


      "x", BCON_DOUBLE (2.0), "tags", "[", "mouse", "cat", "dog", "]");


   docs[3] = BCON_NEW ("x", BCON_DOUBLE (3.0), "tags", "[", "]");


   for (i = 0; i < ndocs; i++) {


      mongoc_bulk_operation_insert (bulk, docs[i]);


      bson_destroy (docs[i]);


      docs[i] = NULL;


   }


   ret = mongoc_bulk_operation_execute (bulk, NULL, &error);


   if (!ret) {


      fprintf (stderr, "Error inserting data: %s\n", error.message);


   }


   mongoc_bulk_operation_destroy (bulk);


   return ret;
}
/* A helper which we'll use a lot later on */
void
print_res (const bson_t *reply)
{


   BSON_ASSERT (reply);


   char *str = bson_as_json (reply, NULL);


   printf ("%s\n", str);


   bson_free (str);
}

bool
distinct (mongoc_database_t *database)
{


   bson_t *command;


   bson_t reply;


   bson_error_t error;


   bool res;


   bson_iter_t iter;


   bson_iter_t array_iter;


   double val;


   command = BCON_NEW ("distinct",


                       BCON_UTF8 (COLLECTION_NAME),


                       "key",


                       BCON_UTF8 ("x"),


                       "query",


                       "{",


                       "x",


                       "{",


                       "$gt",


                       BCON_DOUBLE (1.0),


                       "}",


                       "}");


   res =


      mongoc_database_command_simple (database, command, NULL, &reply, &error);


   if (!res) {


      fprintf (stderr, "Error with distinct: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with reply (in this case iterate through the values) */


   if (!(bson_iter_init_find (&iter, &reply, "values") &&


         BSON_ITER_HOLDS_ARRAY (&iter) &&


         bson_iter_recurse (&iter, &array_iter))) {


      fprintf (stderr, "Couldn't extract \"values\" field from response\n");


      goto cleanup;


   }


   while (bson_iter_next (&array_iter)) {


      if (BSON_ITER_HOLDS_DOUBLE (&array_iter)) {


         val = bson_iter_double (&array_iter);


         printf ("Next double: %f\n", val);


      }


   }
cleanup:


   /* cleanup */


   bson_destroy (command);


   bson_destroy (&reply);


   return res;
}

const char *const COLLECTION_NAME = "things";
/* Our map function just emits a single (key, 1) pair for each tag


   in the array: */
const char *const MAPPER = "function () {"


                           "this.tags.forEach(function(z) {"


                           "emit(z, 1);"


                           "});"


                           "}";
/* The reduce function sums over all of the emitted values for a


   given key: */
const char *const REDUCER = "function (key, values) {"


                            "var total = 0;"


                            "for (var i = 0; i < values.length; i++) {"


                            "total += values[i];"


                            "}"


                            "return total;"


                            "}";
/* Note We can't just return values.length as the reduce function


   might be called iteratively on the results of other reduce


   steps. */

bool
map_reduce_basic (mongoc_database_t *database)
{


   bson_t reply;


   bson_t *command;


   bool res;


   bson_error_t error;


   mongoc_cursor_t *cursor;


   const bson_t *doc;


   bool map_reduce_done = false;


   bool query_done = false;


   const char *out_collection_name = "outCollection";


   mongoc_collection_t *out_collection;


   /* Empty find query */


   bson_t find_query = BSON_INITIALIZER;


   /* Construct the mapReduce command */


   /* Other arguments can also be specified here, like "query" or


      "limit" and so on */


   command = BCON_NEW ("mapReduce",


                       BCON_UTF8 (COLLECTION_NAME),


                       "map",


                       BCON_CODE (MAPPER),


                       "reduce",


                       BCON_CODE (REDUCER),


                       "out",


                       BCON_UTF8 (out_collection_name));


   res =


      mongoc_database_command_simple (database, command, NULL, &reply, &error);


   map_reduce_done = true;


   if (!res) {


      fprintf (stderr, "MapReduce failed: %s\n", error.message);


      goto cleanup;


   }


   /* Do something with the reply (it doesn't contain the mapReduce results) */


   print_res (&reply);


   /* Now we'll query outCollection to see what the results are */


   out_collection =


      mongoc_database_get_collection (database, out_collection_name);


   cursor = mongoc_collection_find_with_opts (


      out_collection, &find_query, NULL, NULL);


   query_done = true;


   /* Do something with the results */


   while (mongoc_cursor_next (cursor, &doc)) {


      print_res (doc);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "ERROR: %s\n", error.message);


      res = false;


      goto cleanup;


   }
cleanup:


   /* cleanup */


   if (query_done) {


      mongoc_cursor_destroy (cursor);


      mongoc_collection_destroy (out_collection);


   }


   if (map_reduce_done) {


      bson_destroy (&reply);


      bson_destroy (command);


   }


   return res;
}

bool
map_reduce_advanced (mongoc_database_t *database)
{


   bson_t *command;


   bson_error_t error;


   bool res = true;


   mongoc_cursor_t *cursor;


   mongoc_read_prefs_t *read_pref;


   const bson_t *doc;


   /* Construct the mapReduce command */


   /* Other arguments can also be specified here, like "query" or "limit"


      and so on */


   /* Read the results inline from a secondary replica */


   command = BCON_NEW ("mapReduce",


                       BCON_UTF8 (COLLECTION_NAME),


                       "map",


                       BCON_CODE (MAPPER),


                       "reduce",


                       BCON_CODE (REDUCER),


                       "out",


                       "{",


                       "inline",


                       "1",


                       "}");


   read_pref = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);


   cursor = mongoc_database_command (


      database, MONGOC_QUERY_NONE, 0, 0, 0, command, NULL, read_pref);


   /* Do something with the results */


   while (mongoc_cursor_next (cursor, &doc)) {


      print_res (doc);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "ERROR: %s\n", error.message);


      res = false;


   }


   mongoc_cursor_destroy (cursor);


   mongoc_read_prefs_destroy (read_pref);


   bson_destroy (command);


   return res;
}

/*


 * Copyright 2016 MongoDB, Inc.


 *


 * Licensed under the Apache License, Version 2.0 (the "License");


 * you may not use this file except in compliance with the License.


 * You may obtain a copy of the License at


 *


 *   http://www.apache.org/licenses/LICENSE-2.0


 *


 * Unless required by applicable law or agreed to in writing, software


 * distributed under the License is distributed on an "AS IS" BASIS,


 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.


 * See the License for the specific language governing permissions and


 * limitations under the License.


 */
#include <mongoc.h>
#include <stdio.h>
#include "constants.c"
#include "../doc-common-insert.c"
#include "distinct.c"
#include "map-reduce-basic.c"
#include "map-reduce-advanced.c"
int
main (int argc, char *argv[])
{


   mongoc_database_t *database = NULL;


   mongoc_client_t *client = NULL;


   mongoc_collection_t *collection = NULL;


   char *host_and_port = NULL;


   int res = 0;


   if (argc != 2) {


      fprintf (stderr, "usage: %s CONNECTION-STRING\n", argv[0]);


      fprintf (stderr,


               "the connection string can be of the following forms:\n");


      fprintf (stderr, "localhost\t\t\t\tlocal machine\n");


      fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n");


      fprintf (stderr,


               "mongodb://user:pass@localhost:27017\t"


               "local machine on port 27017, and authenticate with username "


               "user and password pass\n");


      return 1;


   }


   mongoc_init ();


   if (strncmp (argv[1], "mongodb://", 10) == 0) {


      host_and_port = bson_strdup (argv[1]);


   } else {


      host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]);


   }


   client = mongoc_client_new (host_and_port);


   if (!client) {


      fprintf (stderr, "Invalid hostname or port: %s\n", host_and_port);


      res = 2;


      goto cleanup;


   }


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "test");


   collection = mongoc_database_get_collection (database, COLLECTION_NAME);


   printf ("Inserting data\n");


   if (!insert_data (collection)) {


      res = 3;


      goto cleanup;


   }


   printf ("distinct\n");


   if (!distinct (database)) {


      res = 4;


      goto cleanup;


   }


   printf ("map reduce\n");


   if (!map_reduce_basic (database)) {


      res = 5;


      goto cleanup;


   }


   printf ("more complicated map reduce\n");


   if (!map_reduce_advanced (database)) {


      res = 6;


      goto cleanup;


   }
cleanup:


   if (collection) {


      mongoc_collection_destroy (collection);


   }


   if (database) {


      mongoc_database_destroy (database);


   }


   if (client) {


      mongoc_client_destroy (client);


   }


   if (host_and_port) {


      bson_free (host_and_port);


   }


   mongoc_cleanup ();


   return res;
}

The default log handler prints a timestamp and the log message to stdout, or to stderr for warnings, critical messages, and errors.

You can override the handler with mongoc_log_set_handler(). Your handler function is called in a mutex for thread safety.

/* gcc example-pool.c -o example-pool $(pkg-config --cflags --libs


 * libmongoc-1.0) */
/* ./example-pool [CONNECTION_STRING] */
#include <mongoc.h>
#include <pthread.h>
#include <stdio.h>
static pthread_mutex_t mutex;
static bool in_shutdown = false;
static void *
worker (void *data)
{


   mongoc_client_pool_t *pool = data;


   mongoc_client_t *client;


   bson_t ping = BSON_INITIALIZER;


   bson_error_t error;


   bool r;


   BSON_APPEND_INT32 (&ping, "ping", 1);


   while (true) {


      client = mongoc_client_pool_pop (pool);


      /* Do something with client. If you are writing an HTTP server, you


       * probably only want to hold onto the client for the portion of the


       * request performing database queries.


       */


      r = mongoc_client_command_simple (


         client, "admin", &ping, NULL, NULL, &error);


      if (!r) {


         fprintf (stderr, "%s\n", error.message);


      }


      mongoc_client_pool_push (pool, client);


      pthread_mutex_lock (&mutex);


      if (in_shutdown || !r) {


         pthread_mutex_unlock (&mutex);


         break;


      }


      pthread_mutex_unlock (&mutex);


   }


   bson_destroy (&ping);


   return NULL;
}
int
main (int argc, char *argv[])
{


   const char *uristr = "mongodb://127.0.0.1/?appname=pool-example";


   mongoc_uri_t *uri;


   mongoc_client_pool_t *pool;


   pthread_t threads[10];


   unsigned i;


   void *ret;


   pthread_mutex_init (&mutex, NULL);


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   uri = mongoc_uri_new (uristr);


   if (!uri) {


      fprintf (stderr, "Failed to parse URI: \"%s\".\n", uristr);


      return EXIT_FAILURE;


   }


   pool = mongoc_client_pool_new (uri);


   mongoc_client_pool_set_error_api (pool, 2);


   for (i = 0; i < 10; i++) {


      pthread_create (&threads[i], NULL, worker, pool);


   }


   sleep (10);


   pthread_mutex_lock (&mutex);


   in_shutdown = true;


   pthread_mutex_unlock (&mutex);


   for (i = 0; i < 10; i++) {


      pthread_join (threads[i], &ret);


   }


   mongoc_client_pool_destroy (pool);


   mongoc_uri_destroy (uri);


   mongoc_cleanup ();


   return 0;
}

/* gcc example-client.c -o example-client $(pkg-config --cflags --libs


 * libmongoc-1.0) */
/* ./example-client [CONNECTION_STRING [COLLECTION_NAME]] */
#include <mongoc.h>
#include <stdio.h>
#include <stdlib.h>
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_cursor_t *cursor;


   bson_error_t error;


   const bson_t *doc;


   const char *uristr = "mongodb://127.0.0.1/?appname=client-example";


   const char *collection_name = "test";


   bson_t query;


   char *str;


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   client = mongoc_client_new (uristr);


   if (!client) {


      fprintf (stderr, "Failed to parse URI.\n");


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   bson_init (&query);
#if 0


   bson_append_utf8 (&query, "hello", -1, "world", -1);
#endif


   collection = mongoc_client_get_collection (client, "test", collection_name);


   cursor = mongoc_collection_find_with_opts (


      collection,


      &query,


      NULL,  /* additional options */


      NULL); /* read prefs, NULL for default */


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_json (doc, NULL);


      fprintf (stdout, "%s\n", str);


      bson_free (str);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "Cursor Failure: %s\n", error.message);


      return EXIT_FAILURE;


   }


   bson_destroy (&query);


   mongoc_cursor_destroy (cursor);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

• Determine which host we've connected to with mongoc_cursor_get_host().
• Retrieve more records with repeated calls to mongoc_cursor_next().
• Clone a query to repeat execution at a later point with mongoc_cursor_clone().
• Test for errors with mongoc_cursor_error().

/* gcc example-client.c -o example-client $(pkg-config --cflags --libs


 * libmongoc-1.0) */
/* ./example-client [CONNECTION_STRING [COLLECTION_NAME]] */
#include <mongoc.h>
#include <stdio.h>
#include <stdlib.h>
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_collection_t *collection;


   mongoc_cursor_t *cursor;


   bson_error_t error;


   const bson_t *doc;


   const char *uristr = "mongodb://127.0.0.1/?appname=client-example";


   const char *collection_name = "test";


   bson_t query;


   char *str;


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   if (argc > 2) {


      collection_name = argv[2];


   }


   client = mongoc_client_new (uristr);


   if (!client) {


      fprintf (stderr, "Failed to parse URI.\n");


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   bson_init (&query);
#if 0


   bson_append_utf8 (&query, "hello", -1, "world", -1);
#endif


   collection = mongoc_client_get_collection (client, "test", collection_name);


   cursor = mongoc_collection_find_with_opts (


      collection,


      &query,


      NULL,  /* additional options */


      NULL); /* read prefs, NULL for default */


   while (mongoc_cursor_next (cursor, &doc)) {


      str = bson_as_json (doc, NULL);


      fprintf (stdout, "%s\n", str);


      bson_free (str);


   }


   if (mongoc_cursor_error (cursor, &error)) {


      fprintf (stderr, "Cursor Failure: %s\n", error.message);


      return EXIT_FAILURE;


   }


   bson_destroy (&query);


   mongoc_cursor_destroy (cursor);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

void
fam_flags (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t reply;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bson_t *update;


   bool success;


   /* Find Zlatan Ibrahimovic, the striker */


   BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   BSON_APPEND_UTF8 (&query, "profession", "Football player");


   BSON_APPEND_INT32 (&query, "age", 34);


   BSON_APPEND_INT32 (


      &query, "goals", (16 + 35 + 23 + 57 + 16 + 14 + 28 + 84) + (1 + 6 + 62));


   /* Add his football position */


   update = BCON_NEW ("$set", "{", "position", BCON_UTF8 ("striker"), "}");


   opts = mongoc_find_and_modify_opts_new ();


   mongoc_find_and_modify_opts_set_update (opts, update);


   /* Create the document if it didn't exist, and return the updated document */


   mongoc_find_and_modify_opts_set_flags (


      opts, MONGOC_FIND_AND_MODIFY_UPSERT | MONGOC_FIND_AND_MODIFY_RETURN_NEW);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

void
fam_bypass (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t reply;


   bson_t *update;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bool success;


   /* Find Zlatan Ibrahimovic, the striker */


   BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   BSON_APPEND_UTF8 (&query, "profession", "Football player");


   /* Bump his age */


   update = BCON_NEW ("$inc", "{", "age", BCON_INT32 (1), "}");


   opts = mongoc_find_and_modify_opts_new ();


   mongoc_find_and_modify_opts_set_update (opts, update);


   /* He can still play, even though he is pretty old. */


   mongoc_find_and_modify_opts_set_bypass_document_validation (opts, true);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

void
fam_update (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t *update;


   bson_t reply;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bool success;


   /* Find Zlatan Ibrahimovic */


   BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   /* Make him a book author */


   update = BCON_NEW ("$set", "{", "author", BCON_BOOL (true), "}");


   opts = mongoc_find_and_modify_opts_new ();


   /* Note that the document returned is the _previous_ version of the document


    * To fetch the modified new version, use


    * mongoc_find_and_modify_opts_set_flags (opts,


    * MONGOC_FIND_AND_MODIFY_RETURN_NEW);


    */


   mongoc_find_and_modify_opts_set_update (opts, update);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

void
fam_fields (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t fields = BSON_INITIALIZER;


   bson_t *update;


   bson_t reply;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bool success;


   /* Find Zlatan Ibrahimovic */


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");


   /* Return his goal tally */


   BSON_APPEND_INT32 (&fields, "goals", 1);


   /* Bump his goal tally */


   update = BCON_NEW ("$inc", "{", "goals", BCON_INT32 (1), "}");


   opts = mongoc_find_and_modify_opts_new ();


   mongoc_find_and_modify_opts_set_update (opts, update);


   mongoc_find_and_modify_opts_set_fields (opts, &fields);


   /* Return the new tally */


   mongoc_find_and_modify_opts_set_flags (opts,


                                          MONGOC_FIND_AND_MODIFY_RETURN_NEW);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (&fields);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

void
fam_sort (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t *update;


   bson_t sort = BSON_INITIALIZER;


   bson_t reply;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bool success;


   /* Find all users with the lastname Ibrahimovic */


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   /* Sort by age (descending) */


   BSON_APPEND_INT32 (&sort, "age", -1);


   /* Bump his goal tally */


   update = BCON_NEW ("$set", "{", "oldest", BCON_BOOL (true), "}");


   opts = mongoc_find_and_modify_opts_new ();


   mongoc_find_and_modify_opts_set_update (opts, update);


   mongoc_find_and_modify_opts_set_sort (opts, &sort);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (update);


   bson_destroy (&sort);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

void
fam_opts (mongoc_collection_t *collection)
{


   mongoc_find_and_modify_opts_t *opts;


   bson_t reply;


   bson_t *update;


   bson_error_t error;


   bson_t query = BSON_INITIALIZER;


   bson_t extra = BSON_INITIALIZER;


   bool success;


   /* Find Zlatan Ibrahimovic, the striker */


   BSON_APPEND_UTF8 (&query, "firstname", "Zlatan");


   BSON_APPEND_UTF8 (&query, "lastname", "Ibrahimovic");


   BSON_APPEND_UTF8 (&query, "profession", "Football player");


   /* Bump his age */


   update = BCON_NEW ("$inc", "{", "age", BCON_INT32 (1), "}");


   opts = mongoc_find_and_modify_opts_new ();


   mongoc_find_and_modify_opts_set_update (opts, update);


   /* Abort if the operation takes too long. */


   mongoc_find_and_modify_opts_set_max_time_ms (opts, 100);


   /* Some future findAndModify option the driver doesn't support conveniently


    */


   BSON_APPEND_INT32 (&extra, "futureOption", 42);


   mongoc_find_and_modify_opts_append (opts, &extra);


   success = mongoc_collection_find_and_modify_with_opts (


      collection, &query, opts, &reply, &error);


   if (success) {


      char *str;


      str = bson_as_json (&reply, NULL);


      printf ("%s\n", str);


      bson_free (str);


   } else {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


   }


   bson_destroy (&reply);


   bson_destroy (&extra);


   bson_destroy (update);


   bson_destroy (&query);


   mongoc_find_and_modify_opts_destroy (opts);
}

#include <bcon.h>
#include <mongoc.h>
#include "flags.c"
#include "bypass.c"
#include "update.c"
#include "fields.c"
#include "opts.c"
#include "sort.c"
int
main (void)
{


   mongoc_collection_t *collection;


   mongoc_database_t *database;


   mongoc_client_t *client;


   bson_error_t error;


   bson_t *options;


   mongoc_init ();


   client = mongoc_client_new (


      "mongodb://localhost:27017/admin?appname=find-and-modify-opts-example");


   mongoc_client_set_error_api (client, 2);


   database = mongoc_client_get_database (client, "databaseName");


   options = BCON_NEW ("validator",


                       "{",


                       "age",


                       "{",


                       "$lte",


                       BCON_INT32 (34),


                       "}",


                       "}",


                       "validationAction",


                       BCON_UTF8 ("error"),


                       "validationLevel",


                       BCON_UTF8 ("moderate"));


   collection = mongoc_database_create_collection (


      database, "collectionName", options, &error);


   if (!collection) {


      fprintf (


         stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);


      return 1;


   }


   fam_flags (collection);


   fam_bypass (collection);


   fam_update (collection);


   fam_fields (collection);


   fam_opts (collection);


   fam_sort (collection);


   mongoc_collection_drop (collection, NULL);


   bson_destroy (options);


   mongoc_database_destroy (database);


   mongoc_collection_destroy (collection);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

• readv, writev, seek, and tell.
• General file metadata such as filename and length.
• GridFS metadata such as md5, filename, content_type, aliases, metadata, chunk_size, and upload_date.

• mongoc_client_t
• mongoc_gridfs_t
• mongoc_gridfs_file_list_t
• mongoc_gridfs_file_opt_t

#include <mongoc.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
int
main (int argc, char *argv[])
{


   mongoc_gridfs_t *gridfs;


   mongoc_gridfs_file_t *file;


   mongoc_gridfs_file_list_t *list;


   mongoc_gridfs_file_opt_t opt = {0};


   mongoc_client_t *client;


   mongoc_stream_t *stream;


   bson_t filter;


   bson_t opts;


   bson_t child;


   bson_error_t error;


   ssize_t r;


   char buf[4096];


   mongoc_iovec_t iov;


   const char *filename;


   const char *command;


   bson_value_t id;


   if (argc < 2) {


      fprintf (stderr, "usage - %s command ...\n", argv[0]);


      return 1;


   }


   mongoc_init ();


   iov.iov_base = (void *) buf;


   iov.iov_len = sizeof buf;


   /* connect to localhost client */


   client =


      mongoc_client_new ("mongodb://127.0.0.1:27017?appname=gridfs-example");


   assert (client);


   mongoc_client_set_error_api (client, 2);


   /* grab a gridfs handle in test prefixed by fs */


   gridfs = mongoc_client_get_gridfs (client, "test", "fs", &error);


   assert (gridfs);


   command = argv[1];


   filename = argv[2];


   if (strcmp (command, "read") == 0) {


      if (argc != 3) {


         fprintf (stderr, "usage - %s read filename\n", argv[0]);


         return 1;


      }


      file = mongoc_gridfs_find_one_by_filename (gridfs, filename, &error);


      assert (file);


      stream = mongoc_stream_gridfs_new (file);


      assert (stream);


      for (;;) {


         r = mongoc_stream_readv (stream, &iov, 1, -1, 0);


         assert (r >= 0);


         if (r == 0) {


            break;


         }


         if (fwrite (iov.iov_base, 1, r, stdout) != r) {


            MONGOC_ERROR ("Failed to write to stdout. Exiting.\n");


            exit (1);


         }


      }


      mongoc_stream_destroy (stream);


      mongoc_gridfs_file_destroy (file);


   } else if (strcmp (command, "list") == 0) {


      bson_init (&filter);


      bson_init (&opts);


      bson_append_document_begin (&opts, "sort", -1, &child);


      BSON_APPEND_INT32 (&child, "filename", 1);


      bson_append_document_end (&opts, &child);


      list = mongoc_gridfs_find_with_opts (gridfs, &filter, &opts);


      bson_destroy (&filter);


      bson_destroy (&opts);


      while ((file = mongoc_gridfs_file_list_next (list))) {


         const char *name = mongoc_gridfs_file_get_filename (file);


         printf ("%s\n", name ? name : "?");


         mongoc_gridfs_file_destroy (file);


      }


      mongoc_gridfs_file_list_destroy (list);


   } else if (strcmp (command, "write") == 0) {


      if (argc != 4) {


         fprintf (stderr, "usage - %s write filename input_file\n", argv[0]);


         return 1;


      }


      stream = mongoc_stream_file_new_for_path (argv[3], O_RDONLY, 0);


      assert (stream);


      opt.filename = filename;


      /* the driver generates a file_id for you */


      file = mongoc_gridfs_create_file_from_stream (gridfs, stream, &opt);


      assert (file);


      id.value_type = BSON_TYPE_INT32;


      id.value.v_int32 = 1;


      /* optional: the following method specifies a file_id of any


         BSON type */


      if (!mongoc_gridfs_file_set_id (file, &id, &error)) {


         fprintf (stderr, "%s\n", error.message);


         return 1;


      }


      mongoc_gridfs_file_save (file);


      mongoc_gridfs_file_destroy (file);


   } else {


      fprintf (stderr, "Unknown command");


      return 1;


   }


   mongoc_gridfs_destroy (gridfs);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return 0;
}

#include <bcon.h>
#include <bson.h>
#include <mongoc.h>
#include <stdio.h>
int
main (int argc, char *argv[])
{


   mongoc_matcher_t *matcher;


   bson_reader_t *reader;


   const bson_t *bson;


   bson_t *spec;


   char *str;


   int fd;


   mongoc_init ();
#ifdef _WIN32


   fd = fileno (stdin);
#else


   fd = STDIN_FILENO;
#endif


   reader = bson_reader_new_from_fd (fd, false);


   spec = BCON_NEW ("hello", "world");


   matcher = mongoc_matcher_new (spec, NULL);


   while ((bson = bson_reader_read (reader, NULL))) {


      if (mongoc_matcher_match (matcher, bson)) {


         str = bson_as_json (bson, NULL);


         printf ("%s\n", str);


         bson_free (str);


      }


   }


   bson_reader_destroy (reader);


   bson_destroy (spec);


   mongoc_cleanup ();


   return 0;
}

• primaryPreferred
• secondary
• secondaryPreferred
• nearest

• mongoc_client_set_ssl_opts
• mongoc_client_pool_set_ssl_opts

1.

mongodb is the specifier of the MongoDB protocol.

2.

An optional username and password.

3.

The only required part of the uri. This specifies either a hostname, IP address or UNIX domain socket.

4.

An optional port number. Defaults to :27017.

5.

Extra optional hosts and ports. You would specify multiple hosts, for example, for connections to replica sets.

6.

The name of the database to authenticate if the connection string includes authentication credentials. If /database is not specified and the connection string includes credentials, defaults to the 'admin' database.

7.

Connection specific options.

• db1.example.com on port 27017
• db2.example.com on port 2500

1.

Choose members whose type matches "readPreference".

2.

From these, if there are any tags sets configured, choose members matching the first tag set. If there are none, fall back to the next tag set and so on, until some members are chosen or the tag sets are exhausted.

3.

From the chosen servers, distribute queries randomly among the server with the fastest round-trip times. These include the server with the fastest time and any whose round-trip time is no more than "localThresholdMS" slower.

• mongoc_client_command
• mongoc_client_command_simple
• mongoc_database_command
• mongoc_database_command_simple
• mongoc_collection_command
• mongoc_collection_command_simple

• Command Monitoring: events related to all application operations.
• SDAM Monitoring: events related to the driver's Server Discovery And Monitoring logic.

/* gcc example-command-monitoring.c -o example-command-monitoring \


 *     $(pkg-config --cflags --libs libmongoc-1.0) */
/* ./example-command-monitoring [CONNECTION_STRING] */
#include <mongoc.h>
#include <stdio.h>
typedef struct {


   int started;


   int succeeded;


   int failed;
} stats_t;
void
command_started (const mongoc_apm_command_started_t *event)
{


   char *s;


   s = bson_as_json (mongoc_apm_command_started_get_command (event), NULL);


   printf ("Command %s started on %s:\n%s\n\n",


           mongoc_apm_command_started_get_command_name (event),


           mongoc_apm_command_started_get_host (event)->host,


           s);


   ((stats_t *) mongoc_apm_command_started_get_context (event))->started++;


   bson_free (s);
}
void
command_succeeded (const mongoc_apm_command_succeeded_t *event)
{


   char *s;


   s = bson_as_json (mongoc_apm_command_succeeded_get_reply (event), NULL);


   printf ("Command %s succeeded:\n%s\n\n",


           mongoc_apm_command_succeeded_get_command_name (event),


           s);


   ((stats_t *) mongoc_apm_command_succeeded_get_context (event))->succeeded++;


   bson_free (s);
}
void
command_failed (const mongoc_apm_command_failed_t *event)
{


   bson_error_t error;


   mongoc_apm_command_failed_get_error (event, &error);


   printf ("Command %s failed:\n\"%s\"\n\n",


           mongoc_apm_command_failed_get_command_name (event),


           error.message);


   ((stats_t *) mongoc_apm_command_failed_get_context (event))->failed++;
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_apm_callbacks_t *callbacks;


   stats_t stats = {0};


   mongoc_collection_t *collection;


   const char *uristr = "mongodb://127.0.0.1/?appname=cmd-monitoring-example";


   const char *collection_name = "test";


   bson_t doc;


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   client = mongoc_client_new (uristr);


   if (!client) {


      fprintf (stderr, "Failed to parse URI.\n");


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   callbacks = mongoc_apm_callbacks_new ();


   mongoc_apm_set_command_started_cb (callbacks, command_started);


   mongoc_apm_set_command_succeeded_cb (callbacks, command_succeeded);


   mongoc_apm_set_command_failed_cb (callbacks, command_failed);


   mongoc_client_set_apm_callbacks (


      client, callbacks, (void *) &stats /* context pointer */);


   bson_init (&doc);


   BSON_APPEND_INT32 (&doc, "_id", 1);


   collection = mongoc_client_get_collection (client, "test", collection_name);


   mongoc_collection_drop (collection, NULL);


   mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);


   /* duplicate key error on the second insert */


   mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);


   printf ("started: %d\nsucceeded: %d\nfailed: %d\n",


           stats.started,


           stats.succeeded,


           stats.failed);


   bson_destroy (&doc);


   mongoc_collection_destroy (collection);


   mongoc_apm_callbacks_destroy (callbacks);


   mongoc_client_destroy (client);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}

/* gcc example-sdam-monitoring.c -o example-sdam-monitoring \


 *     $(pkg-config --cflags --libs libmongoc-1.0) */
/* ./example-sdam-monitoring [CONNECTION_STRING] */
#include <mongoc.h>
#include <stdio.h>
typedef struct {


   int server_changed_events;


   int server_opening_events;


   int server_closed_events;


   int topology_changed_events;


   int topology_opening_events;


   int topology_closed_events;


   int heartbeat_started_events;


   int heartbeat_succeeded_events;


   int heartbeat_failed_events;
} stats_t;
static void
server_changed (const mongoc_apm_server_changed_t *event)
{


   stats_t *context;


   const mongoc_server_description_t *prev_sd, *new_sd;


   context = (stats_t *) mongoc_apm_server_changed_get_context (event);


   context->server_changed_events++;


   prev_sd = mongoc_apm_server_changed_get_previous_description (event);


   new_sd = mongoc_apm_server_changed_get_new_description (event);


   printf ("server changed: %s %s -> %s\n",


           mongoc_apm_server_changed_get_host (event)->host_and_port,


           mongoc_server_description_type (prev_sd),


           mongoc_server_description_type (new_sd));
}
static void
server_opening (const mongoc_apm_server_opening_t *event)
{


   stats_t *context;


   context = (stats_t *) mongoc_apm_server_opening_get_context (event);


   context->server_opening_events++;


   printf ("server opening: %s\n",


           mongoc_apm_server_opening_get_host (event)->host_and_port);
}
static void
server_closed (const mongoc_apm_server_closed_t *event)
{


   stats_t *context;


   context = (stats_t *) mongoc_apm_server_closed_get_context (event);


   context->server_closed_events++;


   printf ("server closed: %s\n",


           mongoc_apm_server_closed_get_host (event)->host_and_port);
}
static void
topology_changed (const mongoc_apm_topology_changed_t *event)
{


   stats_t *context;


   const mongoc_topology_description_t *prev_td;


   const mongoc_topology_description_t *new_td;


   mongoc_server_description_t **prev_sds;


   size_t n_prev_sds;


   mongoc_server_description_t **new_sds;


   size_t n_new_sds;


   size_t i;


   context = (stats_t *) mongoc_apm_topology_changed_get_context (event);


   context->topology_changed_events++;


   prev_td = mongoc_apm_topology_changed_get_previous_description (event);


   prev_sds = mongoc_topology_description_get_servers (prev_td, &n_prev_sds);


   new_td = mongoc_apm_topology_changed_get_new_description (event);


   new_sds = mongoc_topology_description_get_servers (new_td, &n_new_sds);


   printf ("topology changed: %s -> %s\n",


           mongoc_topology_description_type (prev_td),


           mongoc_topology_description_type (new_td));


   if (n_prev_sds) {


      printf ("  previous servers:\n");


      for (i = 0; i < n_prev_sds; i++) {


         printf ("      %s %s\n",


                 mongoc_server_description_type (prev_sds[i]),


                 mongoc_server_description_host (prev_sds[i])->host_and_port);


      }


   }


   if (n_new_sds) {


      printf ("  new servers:\n");


      for (i = 0; i < n_new_sds; i++) {


         printf ("      %s %s\n",


                 mongoc_server_description_type (new_sds[i]),


                 mongoc_server_description_host (new_sds[i])->host_and_port);


      }


   }


   mongoc_server_descriptions_destroy_all (prev_sds, n_prev_sds);


   mongoc_server_descriptions_destroy_all (new_sds, n_new_sds);
}
static void
topology_opening (const mongoc_apm_topology_opening_t *event)
{


   stats_t *context;


   context = (stats_t *) mongoc_apm_topology_opening_get_context (event);


   context->topology_opening_events++;


   printf ("topology opening\n");
}
static void
topology_closed (const mongoc_apm_topology_closed_t *event)
{


   stats_t *context;


   context = (stats_t *) mongoc_apm_topology_closed_get_context (event);


   context->topology_closed_events++;


   printf ("topology closed\n");
}
static void
server_heartbeat_started (const mongoc_apm_server_heartbeat_started_t *event)
{


   stats_t *context;


   context =


      (stats_t *) mongoc_apm_server_heartbeat_started_get_context (event);


   context->heartbeat_started_events++;


   printf ("%s heartbeat started\n",


           mongoc_apm_server_heartbeat_started_get_host (event)->host_and_port);
}
static void
server_heartbeat_succeeded (


   const mongoc_apm_server_heartbeat_succeeded_t *event)
{


   stats_t *context;


   char *reply;


   context =


      (stats_t *) mongoc_apm_server_heartbeat_succeeded_get_context (event);


   context->heartbeat_succeeded_events++;


   reply = bson_as_json (


      mongoc_apm_server_heartbeat_succeeded_get_reply (event), NULL);


   printf (


      "%s heartbeat succeeded: %s\n",


      mongoc_apm_server_heartbeat_succeeded_get_host (event)->host_and_port,


      reply);


   bson_free (reply);
}
static void
server_heartbeat_failed (const mongoc_apm_server_heartbeat_failed_t *event)
{


   stats_t *context;


   bson_error_t error;


   context = (stats_t *) mongoc_apm_server_heartbeat_failed_get_context (event);


   context->heartbeat_failed_events++;


   mongoc_apm_server_heartbeat_failed_get_error (event, &error);


   printf ("%s heartbeat failed: %s\n",


           mongoc_apm_server_heartbeat_failed_get_host (event)->host_and_port,


           error.message);
}
int
main (int argc, char *argv[])
{


   mongoc_client_t *client;


   mongoc_apm_callbacks_t *cbs;


   stats_t stats = {0};


   const char *uristr = "mongodb://127.0.0.1/?appname=sdam-monitoring-example";


   bson_t cmd = BSON_INITIALIZER;


   bson_t reply;


   bson_error_t error;


   mongoc_init ();


   if (argc > 1) {


      uristr = argv[1];


   }


   client = mongoc_client_new (uristr);


   if (!client) {


      fprintf (stderr, "Failed to parse URI.\n");


      return EXIT_FAILURE;


   }


   mongoc_client_set_error_api (client, 2);


   cbs = mongoc_apm_callbacks_new ();


   mongoc_apm_set_server_changed_cb (cbs, server_changed);


   mongoc_apm_set_server_opening_cb (cbs, server_opening);


   mongoc_apm_set_server_closed_cb (cbs, server_closed);


   mongoc_apm_set_topology_changed_cb (cbs, topology_changed);


   mongoc_apm_set_topology_opening_cb (cbs, topology_opening);


   mongoc_apm_set_topology_closed_cb (cbs, topology_closed);


   mongoc_apm_set_server_heartbeat_started_cb (cbs, server_heartbeat_started);


   mongoc_apm_set_server_heartbeat_succeeded_cb (cbs,


                                                 server_heartbeat_succeeded);


   mongoc_apm_set_server_heartbeat_failed_cb (cbs, server_heartbeat_failed);


   mongoc_client_set_apm_callbacks (


      client, cbs, (void *) &stats /* context pointer */);


   /* the driver connects on demand to perform first operation */


   BSON_APPEND_INT32 (&cmd, "buildinfo", 1);


   mongoc_client_command_simple (client, "admin", &cmd, NULL, &reply, &error);


   mongoc_client_destroy (client);


   printf ("Events:\n"


           "   server changed: %d\n"


           "   server opening: %d\n"


           "   server closed: %d\n"


           "   topology changed: %d\n"


           "   topology opening: %d\n"


           "   topology closed: %d\n"


           "   heartbeat started: %d\n"


           "   heartbeat succeeded: %d\n"


           "   heartbeat failed: %d\n",


           stats.server_changed_events,


           stats.server_opening_events,


           stats.server_closed_events,


           stats.topology_changed_events,


           stats.topology_opening_events,


           stats.topology_closed_events,


           stats.heartbeat_started_events,


           stats.heartbeat_succeeded_events,


           stats.heartbeat_failed_events);


   bson_destroy (&cmd);


   bson_destroy (&reply);


   mongoc_apm_callbacks_destroy (cbs);


   mongoc_cleanup ();


   return EXIT_SUCCESS;
}